java语言课堂动手动脑

运行 TestInherits.java 示例，观察输出，注意总结父类与子类之间构造方法的调用关系修改Parent构造方法的代码，显式调用GrandParent的另一个构造函数，注意这句调用代码是否是第一句，影响重大！

代码如下

 1 package testInherits;
 2
 3 class Grandparent
 4 {
 5
 6
 7     public Grandparent()
 8      {
 9
10             System.out.println("GrandParent Created.");
11
12 }
13
14
15     public Grandparent(String string)
16     {
17
18             System.out.println("GrandParent Created.String:" + string);
19
20  }
21
22 }
23
24
25
26 class Parent extends Grandparent
27 {
28
29
30     public Parent()
31      {
32
33             //super("Hello.Grandparent.");
34
35             System.out.println("Parent Created");
36
37        //super("Hello.Grandparent.");
38
39       }
40
41 }
42
43
44
45 class Child extends Parent
46 {
47
48
49     public Child()
50      {
51
52         System.out.println("Child Created");
53
54       }
55
56 }
57
58
59
60 public class TestInherits
61 {
62
63
64     public static void main(String args[])
65      {
66
67             Child c = new Child();
68
69   }
70
71 }

第一个是将两个super注释掉

这是将第二个注释掉

这是将第一个注释掉的结果

结论：通过 super 调用基类构造方法，必须是子类构造方法中的第一个语句。如果不是则会出现错误。

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

构造函数是一种特殊的构造方法，在创建对象的时候初始化对象，构造一个对象，先调用其构造方法，而子类拥有父类的成员变量，如果不先调用父类的构造方法，则子类的成员变量也不能正确的初始化，不能反过来是因为，子类继承父类会由多得成员变量，而反过来，父类压根不知道子类有什么成员变量，构造方法就会出错，因此如果反过来，也是错误的。

用反编译结果如图：

参看ExplorationJDKSource.java示例
此示例中定义了一个类A，它没有任何成员：
class A { }
示例直接输出这个类所创建的对象
public static void main(String[] args) {
System.out.println(new A());
}

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

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

代码如下：

 1 package test;
 2
 3 class Pa
 4 {
 5     int x;
 6     public Pa()
 7     {
 8
 9             System.out.println("Parent Created1");
10       }
11     public void show(){
12         System.out.println("Parent Created2");
13     }
14
15 }
16
17
18
19 class Ch extends Pa
20 {
21     int y;
22     public Ch()
23      {
24
25         System.out.println("Child Created1");
26
27       }
28     public void show(){
29         super.show();
30         System.out.println("Parent Created3");
31     }
32
33 }
34
35
36
37 public class text
38 {
39
40
41     public static void main(String args[])
42      {
43
44             Ch c = new Ch();
45     c.show();
46   }
47
48 }

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

请务必动脑总结，然后修改或编写一些代码进行测试，验证自己的想法，最后再看后面的PPT给出的结论。

运行结果：

当子类与父类拥有一样的方法，再调用时看对象是什么类型的就调用什么类型的方法。如果具有相同的字段，子类方法中访问的是子类的字段，如果想访问父类的字段则可以用，super方法来实现。