9.28

动手动脑总结：
枚举类型

点击查看代码

public class EnumTest {

	public static void main(String[] args) {
		Size s=Size.SMALL;
		Size t=Size.LARGE;
		//s和t引用同一个对象？
		System.out.println(s==t);  //不是
		//是原始数据类型吗？
		System.out.println(s.getClass().isPrimitive());//不是
		//从字符串中转换
		Size u=Size.valueOf("SMALL");
		System.out.println(s==u);  //true
		//列出它的所有值
		for(Size value:Size.values()){
			System.out.println(value);
		}
	}

}
 enum Size{SMALL,MEDIUM,LARGE};

其中运行结果为： false false true SMALL MEDIUM LARGE 由此可知：枚举类型不为原始值，可以通过“==”进行比较。 values() 返回枚举类中所有的值 valueOf()方法返回指定字符串值的枚举常量 可以通过value:Size.values()进行遍历。

原码，补码，反码相关知识：
原码：原码是最直观的表示方法，它直接用二进制数表示一个数，包括正负号。在原码中，最高位（最左边的位）是符号位，0 表示正数，1 表示负数。其余位表示数值本身。例如，十进制数 +5 的原码表示为00000101，而 -5 的原码表示为10000101。
反码：反码主要用于表示负数。对于正数，其反码与其原码相同。对于负数，其反码是将原码除符号位外的所有位取反（0 变 1，1 变 0）。例如，十进制数-5的反码表示为11111010。
补码：补码是计算机中最常用的表示方法，用于进行二进制加法运算。对于正数，其补码与其原码相同。对于负数，其补码是其反码加 1。补码的一个重要特性是，任何数的补码加上该数本身，结果总是 0。例如，十进制数 -5 的补码表示为 11111011。
运算符为：
＆：如果相对应位都是1，则结果为1，否则为0
|：如果相对应位都是 0，则结果为 0，否则为 1
^：如果相对应位值相同，则结果为0，否则为1
~：按位取反运算符翻转操作数的每一位，即0变成1，1变成0。
<<：按位左移运算符。左操作数按位左移右操作数指定的位数。

：按位右移运算符。左操作数按位右移右操作数指定的位数。 、
测试代码为：

点击查看代码

package Bufanyuan;

public class Test1 {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}

运行结果为： a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15

Java中的整数使用补码表示。这种表示方法可以有效地处理负数，并且简化了加减运算。在补码表示中，负数的计算也变得与正数一致。

同名变量的处理原则。

点击查看代码

package RepetitionX;

public class Test2 {
    private static int X=1;
    public static void  getX(){
        System.out.println(X);
    }
    public static void main(String[] args) {
        int X=2;
        System.out.println(X);
        getX();
    }
}

运行结果为： 2 1 可知在Java中如果在小范围内变量名与大范围的重复时。在声明小范围内变量名的范围内，用小范围内变量名且不影响大范围的原始值。脱离范围后使用大范围的值。

数值变量的值
通过学习知道了Java中的浮点数并不为我们所想的准确值

点击查看代码

package Double;

public class DoubleTest {

    public static void main(String args[]) {
        System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));
        System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));
        System.out.println("4.015 * 100 = " + (4.015 * 100));
        System.out.println("123.3 / 100 = " + (123.3 / 100));
    }
}

运行结果为：

点击查看代码

0.05 + 0.01 = 0.060000000000000005
1.0 - 0.42 = 0.5800000000000001
4.015 * 100 = 401.49999999999994
123.3 / 100 = 1.2329999999999999

可见Java中的浮点数并不是如我们输入时的准确。 其原因为计算机进行的是二进制运算，我们输入的十进制数字会先转换成二进制，进行运算后再转换为十进制输出。 而N进制可以理解为：数值×基数的幂，Double类型的数值占用64bit，即64个二进制数，除去最高位表示正负符号的位，在最低位上一定会与实际数据存在误差（除非实际数据恰好是2的n次方）。 总结为：在Java中double与flout类为了加快运算，导致在进制换算上存在一些问题，例如有的数不能完全转化，只能无限趋近于之个数。

解决办法为使用BigDecimal类

点击查看代码

package Double;
import java.math.BigDecimal;
public class BigDecimalTest
{
    public static void main(String[] args)
    {
        java.math.BigDecimal f1 = new java.math.BigDecimal("0.05");
        java.math.BigDecimal f2 = java.math.BigDecimal.valueOf(0.01);
        java.math.BigDecimal f3 = new java.math.BigDecimal(0.05);
        System.out.println("使用String构造BigDecimal");
        System.out.println("0.05 + 0.01 = " + f1.add(f2));
        System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f1.divide(f2));
        System.out.println("使用double构造BigDecimal");
        System.out.println("0.05 + 0.01 = " + f3.add(f2));
        System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f3.divide(f2));
    }
}

运行结果为：

点击查看代码

使用String构造BigDecimal
0.05 + 0.01 = 0.06
0.05 - 0.01 = 0.04
0.05 * 0.01 = 0.0005
0.05 / 0.01 = 5
使用double构造BigDecimal
0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125

可见使用double构造时仍会出错，其原因为double类型无法精确的构造BigDecimal对象，及无法精确定位。