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方法来实现。

来源：https://www.cnblogs.com/tkg1314/p/11727463.html

标签

构造方法

string