在前一篇总结中，构造函数必然开始于this()或者super()，也就是说除了Object以外，所有类的构造函数都必然开始于同一类的其他构造函数，或者父类的构造函数。

1. class A {
   
2.         public A() {
   
3.                 System.out.println("A无参构造函数");
   
4.                 show();
   
5.         }
   
6.         public void show() {
   
7.                 System.out.println("A show");
   
8.         }
   
9. }
   
10. 
    
11. class B extends A {
    
12.         protected int b = 222;
    
13.         public B() {
    
14.                 System.out.println("B无参构造函数");
    
15. show();
    
16.         }
    
17.         public void show() {
    
18.                 System.out.println("b = " + b);
    
19.         }
    
20. }

复制代码

在上面两个类中，B继承至A，并且重写了A的show()方法，AB都会在自己的无参构造函数中调用show()方法，new一个B对象，结果如下

1. A无参构造函数
   
2. b = 0
   
3. B无参构造函数
   
4. b = 222

复制代码

当执行到A的无参构造方法时，调用的是B类的show()方法而不是自己的，说明这时没有发生方法的分派，在实例化对象时，构造函数只会调用重写的方法。
我们使用如下方式在new一个A对象：

1. A a = new B();
   
2. A无参构造函数
   
3. b = 0
   
4. B无参构造函数
   
5. b = 222
   

复制代码

结果跟第一次没有什么不同，说明了构造函数只会调用子类重写的方法，不会发生多态。

更有意思的是，注意前面两次结果中b的值，在A的构造参数被调用时b的值为0，而A执行完毕后，b的值才被赋予了222，也就是说类的非静态成员变量的初始化，发生在构造函数执行期间，而且是父类的构造函数执行完毕之后才执行。

执行A的构造方法，调用B类的show，这就是多态啊。如果不是多态，A a ＝ new B()应该调用A的show而不是B的。