1. class A{
   
2.                 public static void print(){
   
3.               System.out.println("A");
   
4.                 }
   
5.                 public A(){
   
6.                          System.out.prinln("A");
   
7.                 }
   
8. }
   
9. public class B extends A{
   
10.          public static void print(){
    
11.                   System.out,.println("B");
    
12.         }
    
13.         public B(){
    
14.                 System.out.println("B");
    
15.         }
    
16.         public static void main(String[] args){
    
17.                 A a=new B();
    
18.                 a=new A();
    
19.         }
    
20. }

复制代码

说出输出结果是什么，why?

A
B
A

就一个知识点：当创建子类对象时，先调用父类的构造函数，再调用子类的构造函数

同意上楼的。

我认为打印的是
A
B
A
因为
A a = new B();        //首先会调用父类A中的构造函数打印A,然后调用子类B的构造函数打印B
a = new A();        //实际上是等同与 A a = new A();        //打印出来的是父类A的构造函数A

A
B
A
因为创建B的时候因为是继承A所以会查找父类的构造函数，所以输出A然后再查找自己的构造函数
你试下改成下面这样，然后发现输出的会是CAB
package com.isoftstone.interview.traffic;
class C
{
        public C(){
                 System.out.println("C");
        }
}
class A extends C{
    public static void print(){
  System.out.println("A");
    }
    public A(){
             System.out.println("A");
    }
}
public class B extends A{
public static void print(){
      System.out.println("B");
}
public B(){
    System.out.println("B");
}               
public static void main(String[] args){
    A a=new B();
}
}

关键知识点是:
  在子类构造函数的第一个语句,隐式地调用了父类的空参构造函数,,即有一个super();语句
然后你知道了

这是用多态的应用，在主函数中A a=new B();这个语句中，先要调用A类中的构造函数，所以首先输出A，再调查用B类中的构造函数，所以再输出B，而a=new A();这个语句就是简单的建立一个A对象，所以调用A的构造函数，即输出A，所以最终打印结果为
A
B
A

A
B   //A a=new B(); 先调用父类构造方法(隐式调用无参的)，再调用子类构造方法
A   //a=new A();调用父类构造方法