课后作业2

动手动脑：运行EnumTest.java：

Size s=Size.SMALL;

Size t=Size.LARGE;

System.out.println(s==t);//结果是false。

s和t分别是枚举类型中的SMALL和LARGE，由此得出两者的值并不相同，引用的是不同对象。

System.out.println(s.getClass().isPrimitive());//false

该行代码判断枚举类型是否是原始数据类型，结果为false。

Size u=Size.valueOf("SMALL");

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。

System.out.println(s==u);  //true

该行代码运行结果为true，由此得出字符串可以转换成枚举。

for(Size value:Size.values()){
    System.out.println(value);
    }

运行结果：

SMALL

MEDIUM

LARGE

此段代码用于输出枚举类型的所有值。

结论：枚举类型是引用数据类型，不属于原始数据类型，每个具体值都引用一个特定的对象。相同的值则引用同一个对象。“==”和“equals（）”方法都可以比对枚举变量的值。

动手动脑：数值的二进制表示：

原码：十进制的二进制表现形式，最左边是符号位，正为0，负为1，。原码弊端：无法计算负数，于是出现了反码。

反码：正数的反码不变，负数的反码在原码的基础上，符号位不变，数值取反，0变1，1变0，反码弊端：跨0出现误差，于是有了补码。

补码：正数的补码不变，即正数的补码，反码，原码都一样，负数的补码在反码的基础上加1.

注意：0的反码和补码都是0，计算机运算的时候都是将原码转成补码进行运算的。

1：与运算&：在java中将4和-5进行与运算，由于计算机中都是用补码进行计算，4的补码为00000000 0000000 00000000 00000100，-5的补码为11111111 11111111 11111111 11111011，将4和-5进行与运算。

4：00000000 0000000 00000000 00000100

-5：11111111 11111111 11111111 11111011         

结果：00000000 00000000 00000000 00000000

由此可知4和-5进行与运算结果为0，java代码的结果同样为0

public class weiyunsuan {
   public static void main(String args[]){
       System.out.println(4&-5);
   }
}

2：或运算|：　两个数相同位置的比特进行或运算，若其中一个为1则结果为1，否个结果为0。例如：-2的补码为11111111 11111111 11111111 11111110，5的补码：00000000 00000000 00000000 00000101，.将-2 和 5 的补码进行或运算：

-2： 11111111 11111111 11111111 1111111

5： 00000000 00000000 00000000 00000101

结果：11111111 11111111 11111111 11111111

结果显然是负数，经过转为反码再转为原码后可知该数为-1

Java代码：

public class weiyunsuan {
   public static void main(String args[]){
       System.out.println(-2|5);
   }
}

java的运行结果同样为-1.

3：异或运算^:　两个数相同位置的比特进行或运算，若两个数均为0或1，则结果为0，否则为1。例如1^-5，1的补码为：00000000 00000000 00000000 00000001，-5的补码为：11111111 11111111 11111111 11111011，运算：

00000000 00000000 00000000 00000001

11111111 11111111 11111111 11111011

11111111 11111111 11111111 11111010

由此得到补码转原码最终得到的结果为-6

java代码：

public class weiyunsuan {
   public static void main(String args[]){
       System.out.println(1^-5);//结果为-6
   }
}

4：取反运算~：若位数为0，则取反后为1，若为1，取反后为0。例如对2取反：2的补码与原码一致：00000000 00000000 00000000 00000010，取反后：111111111 11111111 11111111 11111101，此时补码为负数，转为原码后为-3。

java中System.out.println(~2);结果也为-3。

5：左移<<:符号位不变，高位溢出截断，低位补零,例如-1<<2结果为-4

System.out.println(-1<<2);

6：右移>>：符号位不变，低位溢出截断，高位用符号位填充.8>>2=2

System.out.println(8>>2);

 

动手动脑：变量的作用域：

代码：

public class Addition {
   static int a=10;
   public static void main( String args[] )
   {
       int a=88;
       System.out.println(a);
   }
}

结果：88

由此得出：变量只在其定义的作用域内有效，全局变量和局部变量同名时：局部变量优先级更高，全局变量被屏蔽，主要是为了解决变量命名冲突的问题，确保在不同的作用域中可以使用相同的变量名。

 

 

动手实验（TestDouble.java）：

public class Addition {
      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

结论：使用double类型的数值进行计算，结果是不精确的。一般情况下二进制转为十进制我们所使用的是按权相加法。十进制转二进制是除2取余，逆序排列法。十进制小数到二进制小数一般是整数部分除 2 取余，逆序排列，小数部分使用乘 2 取整数位，顺序排列。二进制小数到十进制小数还是使用按权相加法。计算机在存储小数时肯定是有长度限制的，所以会进行截取部分小数进行存储，从而导致计算机存储的数值只能是个大概的值，而不是精确的值。从这里看出来我们的计算机根本就无法使用二进制来精确的表示 2.1 这个十进制数字的值，连表示都无法精确表示出来，计算肯定是会出现问题的。解决方法用高精度运算解决java中的BigDecimal

public class Addition {
      public static void main( String args[] )
   {
       BigDecimal f1 = new BigDecimal("0.05");
       BigDecimal f2 = BigDecimal.valueOf(0.01);
       BigDecimal f3 = new 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

 

动手动脑：

以下代码的输出结果是什么？

int X=100;

int Y=200;

System.out.println("X+Y="+X+Y);

System.out.println(X+Y+"=X+Y");

为什么会有这样的输出结果？

结果：

X+Y=100200

300=X+Y

原因：使用计算符+将String和其他类型连接会得到一个新的String类型。前者直接与X相加形成字符串又与Y相加形成新的字符串，后者则是X与Y相加后得到新的数字，再与字符串相加。