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

 然后测试下

Java代码  收藏代码
  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.   
  9.         //把child转换成parent对象  
  10.         Parent parent=child;  
  11.   
  12.         System.out.printf("转换后的名称:%s,年龄：%d,包名：%s%n",parent.name,parent.age,parent.kind);  
  13.         //输出：转换后的名称:Parent,年龄：50,包：javastudy.extendsstudy.parent  
  14.   
  15.         System.out.printf("子类访问父类被隐藏的实例变量name:%s%n",child.getParentName());  
  16.         //输出：子类访问父类被隐藏的实例变量name:Parent  
  17.           
  18.         System.out.printf("子类访问父类被隐藏的静态变量kind:%s",child.getParentKind());  
  19.         //输出：子类访问父类被隐藏的静态变量kind:javastudy.extendsstudy.parent  
  20.   
  21.         child.getName();  
  22.         //输出：child的getName()被调用了  
  23.   
  24.         //**************注意看这个方法，返回的还是子类的getName  
  25.         parent.getName();  
  26.         //输出：child的getName()被调用了  
  27.   
  28.         child.getKind();  
  29.         //输出：child的getkind()方法被调用了  
  30.   
  31.         parent.getKind();  
  32.         //输出：parent的getKind()方法被调用了  
  33.     }  
  34. }  

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

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

posted on 2016-10-07 13:50  暗黑迪迦  阅读(105)  评论(0)  编辑  收藏  举报