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变量遵循“同名变量的屏蔽原则”，请课后阅读相关资料弄清楚相关知识，然后自己编写一些测试代码，就象本示例一样，有意识地在不同地方定义一些同名变量，看看输出的到底是哪个值：
- //父类
- class Parent
- {
- public static String kind="javastudy.extendsstudy.parent";
- public static int age=50;
- public String name="Parent";
- //静态方法，返回包名
- public static String getKind()
- {
- System.out.println("parent的getKind()方法被调用了");
- return kind;
- }
- //静态方法，返回年龄
- public static int getAge()
- {
- System.out.println("Parent的getAge()方法被调用了");
- return age;
- }
- //实例方法，返回姓名
- public String getName()
- {
- System.out.println("Parent的getName()方法被调用了");
- return this.name;
- }
- }
- //子类
- class Child extends Parent
- {
- public static String kind="javastudy.extendsstudy.child";
- public int age=25;
- public String name="child";
- //隐藏父类静态方法
- public static String getKind()
- {
- System.out.println("child的getkind()方法被调用了");
- return kind;
- }
- //获取父类包名
- public static String getParentKind()
- {
- return Parent.kind;
- }
- //覆盖父类实例方法
- public String getName()
- {
- System.out.println("child的getName()被调用了");
- return this.name;
- }
- //获取父类名称
- public String getParentName()
- {
- return super.name;
- }
- /*
- *错误，实例方法不能覆盖父类的静态方法
- public int getAge()
- {
- return this.age;
- }
- */
- }
然后测试下
- class Test
- {
- public static void main(String[] args)
- {
- Child child=new Child();
- System.out.printf("子类名称：%s,年龄：%d,包名:%s%n",child.name,child.age,child.kind);
- //输出：子类名称：child,年龄：25,包:javastudy.extendsstudy.child
- //把child转换成parent对象
- Parent parent=child;
- System.out.printf("转换后的名称:%s,年龄：%d,包名：%s%n",parent.name,parent.age,parent.kind);
- //输出：转换后的名称:Parent,年龄：50,包：javastudy.extendsstudy.parent
- System.out.printf("子类访问父类被隐藏的实例变量name:%s%n",child.getParentName());
- //输出：子类访问父类被隐藏的实例变量name:Parent
- System.out.printf("子类访问父类被隐藏的静态变量kind:%s",child.getParentKind());
- //输出：子类访问父类被隐藏的静态变量kind:javastudy.extendsstudy.parent
- child.getName();
- //输出：child的getName()被调用了
- //**************注意看这个方法，返回的还是子类的getName
- parent.getName();
- //输出：child的getName()被调用了
- child.getKind();
- //输出：child的getkind()方法被调用了
- parent.getKind();
- //输出：parent的getKind()方法被调用了
- }
- }
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"); 为什么会有这样的输出结果？
加号在前为和的意思，在后为加法求和。