动手动脑（三）

继承条件下的构造方法调用

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

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

运行结果：

若打开Parent方法中下方的super，会报错

结论：通过 super 调用基类构造方法，必须是子类构造方法中的第一个语句。

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

构造函数主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载。不能反过来，子类继承了父类所有的对象和成员变量，子类肯定要先初始化，才能正确使用父类的对象和成员变量。父类并不知道会有什么子类，也不知道子类有什么特殊的对象和成员变量，无法提前初始化。

子类与父类方法间的关系

由于Java并未对子类方法的命名做过多的限制，因此，子类与父类各自定义的方法之间，可以出现以下三种情况扩充（Extends)：子类定义的方法父类没有同名覆盖/重写（Override）：子类父类定义了完全一样的方法重载（Overloads）：子类有父类的同名方法，但两者的参数类型或参数数目不一样。

运行以下代码，展示程序运行结果并解释为什么会得到这样的输出

 1 public class ParentChildTest {
 2     public static void main(String[] args) {
 3         Parent parent=new Parent();
 4         parent.printValue();
 5         Child child=new Child();
 6         child.printValue();
 7         
 8         parent=child;
 9         parent.printValue();
10         
11         parent.myValue++;
12         parent.printValue();
13         
14         ((Child)parent).myValue++;
15         parent.printValue();
16         
17     }
18 }
19 
20 class Parent{
21     public int myValue=100;
22     public void printValue() {
23         System.out.println("Parent.printValue(),myValue="+myValue);
24     }
25 }
26 class Child extends Parent{
27     public int myValue=200;
28     public void printValue() {
29         System.out.println("Child.printValue(),myValue="+myValue);
30     }
31 }

运行结果：

结论：当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。如果子类被当作父类使用,则通过子类访问的字段是父类的!

多态的好处：

通过在编程中应用多态，可以使我们的代码具有更强的适用性。当需求变化时，多态特性可以帮助我们将需要改动的地方减少到最低限度。

多态编程有两种主要形式：（1）继承多态（2）接口多态：使用接口代替抽象基类。