Java第七周课堂示例总结

一、super();调用基类构造方法

代码：

 class Grandparent{
     public Grandparent(){
         System.out.println("GrandParent Created.");
     }
     public Grandparent(String string) {
         System.out.println("GrandParent Created.String:" + string);
      }
 }
 class Parent2 extends Grandparent
 {
     public Parent2() {
             //super("Hello.Grandparent.");
             System.out.println("Parent2 Created");
                // super("Hello.Grandparent.");
      }
 }
 class Child2 extends Parent2 {
     public Child2() {
         System.out.println("Child2 Created");
       }
 }
 public class TestInherits {
     public static void main(String args[]){
             Child2 c = new Child2();
     }
 }  

第一次运行结果：

第二次：（super语句放在第一句）

第三次运行结果：（super语句放在第二位）报错：super必须放在第一位

思索：为什么子类的构造方法在运行之前，必须调用父类的构造方法？能不能反过来？为什么不能反过来？

构造函数的作用是完成类的初始化，子类继承了父类的成员方法和成员变量，如果不首先调用，则从父类继承来的成员得不到初始化。

如果反过来调用，父类不知道子类的变量，并且子类中的部分从父类继承来的变量得不到正确的初始化，故顺序不能改变。

二、JVM的一种默认实现

请按照以下步骤进行技术探险：

（1）使用javap –c命令反汇编ExplorationJDKSource.class；

（2）阅读字节码指令，弄明白println()那条语句到底调用了什么？

（3）依据第（2）得到的结论，使用Eclipse打开JDK源码，查看真正被执行的代码是什么

原因：

前面示例中，main方法实际上调用的是： public void println(Object x)，这一方法内部调用了String类的valueOf方法。 valueOf方法内部又调用Object.toString方法： public String toString() { return getClass().getName() +"@" + Integer.toHexString(hashCode()); } hashCode方法是本地方法，由JVM设计者实现： public native int hashCode();

三、

 public class Fruit{
     public String toString()
     {
         return "Fruit toString.";
     }
     public static void main(String args[])
     {
         Fruit f=new Fruit();
         System.out.println("f="+f);
         System.out.println("f="+f.toString());
     }
 }

注意最后两句句，一个字串和一个对象“相加”，得到以下结果：

原因分析：Fruit类覆盖了Object类的toString方法。在“+”运算中,当任何一个对象与一个String对象，连接时，会隐式地调用其toString()方法，默认情况下，此方法返回“类名 @ + hashCode”。为了返回有意义的信息，子类可以重写toString()方法。

四、方法覆盖

（1）覆盖方法的允许访问范围不能小于原方法。

（2）覆盖方法所抛出的异常不能比原方法更多。

（3）声明为final方法不允许覆盖。 例如，Object的getClass()方法不能覆盖。

（4）不能覆盖静态方法。

请自行编写代码测试以下特性：在子类中，若要调用父类中被覆盖的方法，可以使用super关键字。

运行结果：

五、多态

多态性的定义是：同一操作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的结果。即相同的一条语句，在不同的运行环境中可以产生不同的运行结果。

多态的最本质特征就是父类（或接口）变量可以引用子类（或实现了接口的类）对象。换句话说：子类对象可以被当成基类对象使用!

特别地，Java类库的最顶层类是Object。因此每个对象都可以赋值给Object变量。

子类对象可以直接赋给基类变量。 基类对象要赋给子类对象变量,必须执行类型转换, 其语法是: 子类对象变量=(子类名)基类对象名;

也不能乱转换。如果类型转换失败Java会抛出以下这种异常: ClassCastException

例子：

 public class TestInstanceof
 {
     public static void main(String[] args)
     {
         //可以使用instanceof运算符判断一个对象是否可以转换为指定的类型：
         //声明hello时使用Object类，则hello的编译类型是Object，Object是所有类的父类
         //但hello变量的实际类型是String
         Object hello = "Hello";
         //String是Object类的子类，所以返回true。
         System.out.println("字符串是否是Object类的实例：" + (hello instanceof Object));
         //返回true。
         System.out.println("字符串是否是String类的实例：" + (hello instanceof String));
         //返回false。
         System.out.println("字符串是否是Math类的实例：" + (hello instanceof Math));
         //String实现了Comparable接口，所以返回true。
         System.out.println("字符串是否是Comparable接口的实例：" + (hello instanceof Comparable));
         String a = "Hello";
         //String类既不是Math类，也不是Math类的父类，所以下面代码编译无法通过
         //System.out.println("字符串是否是Math类的实例：" + (a instanceof Math));
     }
 }

运行结果：

六、“类型转换”知识点考核

下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么?

 class Mammal{}
 class Dog extends Mammal {}
 class Cat extends Mammal{}
 public class TestCast
 {
     public static void main(String args[])
     {
         Mammal m;
         Dog d=new Dog();
         Cat c=new Cat();
         m=d;
         //d=m;
         d=(Dog)m;
         //d=c;
         //c=(Cat)m;
     }
 }

解答：注释的三个语句皆会出现编译错误问题

12、14行为同一父类的子类对象不能相互转换，15行则是因为m对象之前已经被强转，所以不能再次转换。

七、子类和父类定义了一模一样的字段和方法

 public class ParentChildTest {
     public static void main(String[] args) {
         Parent parent=new Parent();
         parent.printValue();
         Child child=new Child();
         child.printValue();

         parent=child;
         parent.printValue();

         parent.myValue++;
         parent.printValue();

         ((Child)parent).myValue++;
         parent.printValue();
     }
 }
 class Parent{
     public int myValue=;
     public void printValue() {
         System.out.println("Parent.printValue(),myValue="+myValue);
     }
 }
 class Child extends Parent{
     public int myValue=;
     public void printValue() {
         System.out.println("Child.printValue(),myValue="+myValue);
     }
 }

运行结果：

回答问题：

1. 左边的程序运行结果是什么？ 2. 你如何解释会得到这样的输出？ 3. 计算机是不会出错的，之所以得到这样的运行结果也是有原因的， 那么从这些运行结果中，你能总结出Java的哪些语法特性？

总结：

当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。 这个特性实际上就是面向对象“多态”特性的具体表现。

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。 如果子类被当作父类使用,则通过子类访问的字段是父类的! 牢记：在实际开发中，要避免在子类中定义与父类同名 的字段。不要自找麻烦！——但考试除外，考试 中出这种题还是可以的。