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

//父类
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"); 为什么会有这样的输出结果？

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