动手动脑（Java）

1.仔细阅读示例: EnumTest.java，运行它，分析运行结果？ 你能得到什么结论？你掌握了枚举类型的基本用法了吗？

答：

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};

出现这样的结果：<1>s与t不一样所以显示false，s的类不是Primitive，u是SMALL，所以显示true。<2>结论：相同的显示true，不一样的显示false.

枚举类型是引用类型！ 枚举不属于原始数据类型，它的每个具体值都引用一个特定的对象。相同的值则引用同一个对象。 可以使用“==”和equals()方法直接比对枚举变量的值，换句话说，对于枚举类型的变量，“==”和equals()方法执行的结果是等价的。

<3>掌握了。

2.反码、补码、源码：

00110011的反码就是11001100补码就是计算机里存储指令都用补码举例就是9的原码是0000100反码是11110110补码是00001001 （如果是-9）那么符号位变成1 就是10001001

3.Java变量遵循“同名变量的屏蔽原则”，请课后阅读相关资料弄清楚相关知识，然后自己编写一些测试代码，就象本示例一样，有意识地在不同地方定义一些同名变量，看看输出的到底是哪个值：

1. //父类
2. class Parent
3. {
4. public static String kind="javastudy.extendsstudy.parent";
5. public static int age=50;
6. public String name="Parent";
7. //静态方法，返回包名
8. public static String getKind()
9. {
10. System.out.println("parent的getKind()方法被调用了");
11. return kind;
12. }
13. //静态方法，返回年龄
14. public static int getAge()
15. {
16. System.out.println("Parent的getAge()方法被调用了");
17. return age;
18. }
19. //实例方法，返回姓名
20. public String getName()
21. {
22. System.out.println("Parent的getName()方法被调用了");
23. return this.name;
24. }
25. }
26. //子类
27. class Child extends Parent
28. {
29. public static String kind="javastudy.extendsstudy.child";
30. public int age=25;
31. public String name="child";
32. //隐藏父类静态方法
33. public static String getKind()
34. {
35. System.out.println("child的getkind()方法被调用了");
36. return kind;
37. }
38. //获取父类包名
39. public static String getParentKind()
40. {
41. return Parent.kind;
42. }
43. //覆盖父类实例方法
44. public String getName()
45. {
46. System.out.println("child的getName()被调用了");
47. return this.name;
48. }
49. //获取父类名称
50. public String getParentName()
51. {
52. return super.name;
53. }
54. /*
55. *错误，实例方法不能覆盖父类的静态方法
56. public int getAge()
57. {
58. return this.age;
59. }
60. */
61. }

然后测试下

1. class Test
2. {
3. public static void main(String[] args)
4. {
5. Child child=new Child();
6. System.out.printf("子类名称：%s,年龄：%d,包名:%s%n",child.name,child.age,child.kind);
7. //输出：子类名称：child,年龄：25,包:javastudy.extendsstudy.child
8. //把child转换成parent对象
9. Parent parent=child;
10. System.out.printf("转换后的名称:%s,年龄：%d,包名：%s%n",parent.name,parent.age,parent.kind);
11. //输出：转换后的名称:Parent,年龄：50,包：javastudy.extendsstudy.parent
12. System.out.printf("子类访问父类被隐藏的实例变量name:%s%n",child.getParentName());
13. //输出：子类访问父类被隐藏的实例变量name:Parent
14. System.out.printf("子类访问父类被隐藏的静态变量kind:%s",child.getParentKind());
15. //输出：子类访问父类被隐藏的静态变量kind:javastudy.extendsstudy.parent
16. child.getName();
17. //输出：child的getName()被调用了
18. //**************注意看这个方法，返回的还是子类的getName
19. parent.getName();
20. //输出：child的getName()被调用了
21. child.getKind();
22. //输出：child的getkind()方法被调用了
23. parent.getKind();
24. //输出：parent的getKind()方法被调用了
25. }
26. }

4.

看着这个图，再查查Java中每个数据类型所占的位数，和表示数值的范围，你能得出什么结论？高精度向低精度转化，不发生精度缺失，否则可能相反。

5.<1>你看到了什么样的输出，意外吗？不意外。

<2>为什么double类型的数值进行运算得不到“数学上精确”的结果？    首先得从计算机本身去讨论这个问题。我们知道，计算机并不能识别除了二进制数据以外的任何数据。无论我们使用何种编程语言，在何种编译环境下工作，都要先 把源程序翻译成二进制的机器码后才能被计算机识别。

<3>解决方法：  思路很简单，我们先通过BigDecimal(double value)方法，将double型数据转换成BigDecimal数据，然后就可以正常进行精确计算了。等计算完毕后，我们可以对结果做一些处理，比如 对除不尽的结果可以进行四舍五入。最后，再把结果由BigDecimal型数据转换回double型数据。

6.

以下代码的输出结果是什么？ int X=100; int Y=200; System.out.println("X+Y="+X+Y); System.out.println(X+Y+"=X+Y"); 为什么会有这样的输出结果？

   加号在前为和的意思，在后为加法求和。