java结构设计_Java基本程序结构设计

⦁ Java 对大小写敏感，大小写拼写错误将导致程序无法运行

⦁类名应该定义为大写，采用骆驼命名法

⦁源代码的文件名必须与public类的名称一致，

⦁每个Java应用程序都必须要有一个main方法，Java虚拟机会从指定类的main方法开始执行

⦁Java中注释是不可以嵌套的，

⦁Java中有4种基本数据类型：都是有符号类型

四种整型

⦁byte1个字节

⦁short 2个字节

⦁int 4个字节

⦁long 8个字节 带有后缀 L

两种浮点型 ：

⦁float 4个字节

⦁double 8个字节

在大多数情况下都应该使用double 类型，浮点数值不适用禁止出现舍入误差的金融计算中，如计算图书金额相加之类的计算，都不应该使用浮点类型，而应该使用BigDecimal类，来进行计算，看下面这段代码，另外，Double类中的常量用来表示正负无穷大，NaN表示不是一个数字，

可以使用isNaN() 方法来判断一个变量是否不是一个数字

public static void main(String[] args) {

// 0.8999999999999999

System.out.println(2.0 - 1.1);

}

public static final double POSITIVE_INFINITY = 1.0 / 0.0;

public static final double NEGATIVE_INFINITY = -1.0 / 0.0;

public static final double NaN = 0.0d / 0.0;

⦁ 表示真值的boolean型

⦁字符型(char 类型)

⦁char类型用来表示单个字符，最好不要使用char类型，

⦁使用final关键字来声明一个常量，

关键字final关键字修饰的变量，表示这个变量只能被赋值一次，

一旦被赋值之后就不能修改，

常量名常用大写表示，

public static final int a = 10;这个常量可以被其他类使用，

final声明的 常量必须确保在构造方法执行之后，会被赋值，并且在后面的操作中，不能够对它进行修改，

final关键字大多数用于修饰基本数据类型，或者不可变类，

不可变类：若类中的每一个方法都不会改变其对象，那么就是不可变的，如String类

如果使用了final关键字修饰了一个可变类，仅仅意味着对象变量中的引用不能改变，对象的属性是可以改变的，

使用final关键字修饰的方法，只能被继承，不能被重写

使用final关键字修饰的类，不能继承

⦁整数除以0将会产生一个异常，浮点数除以0将会得到无穷大或者NaN的结果

System.out.println(1 / 0);

Exception in thread "main" java.lang.ArithmeticException: / by zero

at yu.base.Demo1.main(Demo1.java:11)

System.out.println(10.0 / 0);

//Infinity

⦁ 运算符

&& 和 || 都是短路运算符，

expression1 && expression2 当表达式1已经能够确定整个表达式的正确性时，将不会计算表达式2的部分，这种操作能够避免一些错误产生,如:

f(name != null && name == "虞四明"){} ,当name 不为null时，才进行第二个判断

f(name == "虞四明" && name != null ){} , 若这样判断，name为null时，空指针异常

⦁Java支持三元操作，

condition ? expression1:expression2 ，当条件为真时，计算表达式1，否则计算2

输出 a 和 b 中较大的数

System.out.println(a > b ? a : b);

⦁位运算符

整数在计算中存放的都是其原码对应的补码，我们来看一个例子

System.out.println(Integer.toBinaryString(1)); // 00000000000000000000000000000001

System.out.println(Integer.toBinaryString(-1)); // 11111111111111111111111111111111

1 对应的原码是，00000000 00000000 00000000 00000001

-1对应的原码是，10000000 00000000 00000000 00000001

1 对应的补码就是原码,

-1对应的补码是, 111111111 111111111 111111111 111111111 ，符号为不动，每位取反末尾加1

对 1 进行 ‘非’ 操作，也就是 ~1.我们来看一下结果

System.out.println(Integer.toBinaryString(~1));// 11111111111111111111111111111110

System.out.println(~1);// -2

结果是11111111111111111111111111111110,不错，我们来得到这个二进制数的原码，

符号为不动，

每位取反 : 10000000000000000000000000000001

末尾加一 : 10000000000000000000000000000010 也就是对应了 -2的原码，所以输出为 -2

⦁& 运算符 当两个二进制数同时为 1 时，结果为 1.否则为 0 相当于一个 与门

即 1&1 = 1 ; 1 & 0 = 0 ;0 &1 = 0

1100 & 1011 = 1000

我们来看一个例子：

3的补码 0...011，5的补码 0...101 得到的结果 0...1

12的补码 0...1100 ,11的补码 0...1011 得到的结果 0...1000 也就是 8

-1的补码 1....1 , -2 的补码 1...10 得到的结果1...10 还是 -2

System.out.println(3&5); // 1

System.out.println(12&11); // 8

System.out.println(-1&-2); // -2

⦁| 运算符，当有一个操作数是1时，结果为1，否则为 0 ,相当于一个或门

1 | 1 = 1 ; 0 |1 = 1; 0 | 0 =0

来看例子：

3 | 5 相当于 101 | 11 = 111 —> 7

12 | 11 相当于 1100 | 1011 = 1111 ---> 15

-1 | -2 相当于 1...1 | 1...10 = 1...1 --> -1

System.out.println(3&5); // 7

System.out.println(12&11); // 15

System.out.println(-1&-2); // -1

⦁^ 运算符 相当于一个异或门

1 ^ 1 = 0 ; 0 ^ 0 = 0 ;

1 ^ 0 = 1; 0 ^ 1 = 1

只有当 两个操作数不同时，才为 1,来看例子：

3 ^ 5 相当于 101 ^ 11 = 110 —> 6

12 ^ 11 相当于 1100 ^ 1011 = 0111 --> 7

-1 ^ -2 相当于 1...1 ^ 1...10 = 1 --> 1

⦁~ 运算符， 相当于一个 反相器

~0 =1

~1 = 0；

来看例子：

~1 相当于 0....01 ---> 1...10 即-2 的补码

System.out.println(~1); // -2

注意：& 和 | 运算也可以应用在 boolean 值上，得到的结果也是boolean 值，但是这两个运算不是短路运算。

⦁>> 运算符，算术移位将二进制数 右移，符号位不变，空的位置补上符号位，即正数补 0，负数补 1，

可以类比10进制，将 1000右移 3 位 变为1，相当于 / 10的三次方

System.out.println(8 >> 3); // 1,将8的补码右移 3位，相当于 / 8 也就是 2的三次方

⦁<< 运算符，将二进制数 左移 , 最高位将会被丢弃，最低为补 0

可以类比10进制，将 1 左移 3 为变为， 1000 相当于 * 10的三次方

System.out.println(1 << 3); // 8 ,将 1 的补码左移 3位，相当于 * 8 也就是 2的3次方

⦁>>> 右移运算，但是用0 填补最高位，符号为也被替换，看例子

System.out.println(Integer.toBinaryString(-2)); // 11111111111111111111111111111111

System.out.println(Integer.toBinaryString(-2 >> 1)); // 11111111111111111111111111111110

System.out.println(Integer.toBinaryString(-2 >>> 1)); // 01111111111111111111111111111111

同样是右移运算

>> 使用符号位填充高位,这种称为算术移位，符号位不动

>>> 使用0填充高位，这种称为逻辑移位，符号位参与运算

注意，对于移位运算符右侧的参数需要进行mod 32 或者 mod 64 运算，int 型mod 32

long型 mod 64，如 1 << 3 和 1 << 35 是一样的都是8,

⦁Math.round方法返回的是long型数值，

long round = Math.round(99.991);