构造器问题

Question

class Father
{
public Father()
{
System.out.println("调用Father()");
}
}
public class Son extends Father
{
public Son()
{
System.out.println("调用Son()");
}
public static void test()
{
System.out.println("调用test()");
}
public static void main(String[] args)
{
Father father = new Son();
System.out.println("-----------------------------");

test();
test();
}
}
“Java会自动在导出类构造器中插入对基类构造器的调用”，一直以来我对这句话的理解都是稀里糊涂的。今天我想明白到底
是什么意思。这道题我在没有看到这句话之前，与答案是一致的，看到之后不一样了，我的答案是：
调用Father()
调用Father()
调用Son()
------------
调用test()
调用test()
我的理解：既然是调用了基类构造器他就应该执行，并输出“调用Father()”，就像调用test()方法一样，调用一次输出一次
问题就是为什么调用了而没有执行，难道这只是名义上的？还是构造器的调用与方法的调用根本就是一回事。
当然就是有参数的构造器在子类中显示的调用也不会输出上述答案。给指点一下迷津。谢谢！！（初始化顺序的话就不要讲解了）

Answer 1

输出是

调用Father() 
调用Son() 
------------ 
调用test() 
调用test()  Father father = new Son();只是创建了一个son对象，先调用父类构造器，在调用子类的构造器。当然只有一个“调用Father() ”输出，
上面只是一个上转型对象，并没有再创建一个father。Father father = new Son();和new Son();两个输出一样。

Answer 2

调用一次输出一次 
问题就是为什么调用了而没有执行，难道这只是名义上的？
楼主把：
Father father = new Son();
理解为了先new一个父类，然后再new一个子类了，其实不是，只是new出了一个子类对象吗，所以只是调用一次父类构造函数，然后调用子类本身的构造函数，所以输出结果是：
调用Father()
调用Son()

Answer 3

感觉楼主对JAVA中的多态问题还是没有理解清楚，
输入结果应该还是
调用Father()
调用Son()
-----------------------------
调用test()
调用test()Father father = new Son(); 
就是多态的一个条件，父类指用子类的引用，new Son()调用子类构造方法，默认是先调用父类的构造方法，再调用子类自己的构造方法．

Answer 4

调用Father() 
调用Son() 
------------ 
调用test() 
调用test() 
我的答案是这个。Father father = new Son(); 这个中间是父类调用子类的引用，故只有这一个调用father（）；谢谢

Answer 5

楼上的几位，结果我是知道的，现在让你们解释的不是这个问题。我把它说的再简单一点。
我们都知道，方法你调用几次它就会执行几次，如题中的test()方法。父类构造器最初执行的一次我知道，而到了子类，子类又在他的构造器中调用父类的构造器，那它为什么没有像test()那样;你调用它两次，它同样也输出两次。

Answer 6

父类构造器,并没有在创建子类的时候调用一次~~~而是在创建子类对象的时候,先调用父类的构造器,然后再用子类的构造器,所以是输出
调用Father()
调用Son()
-----------------------------
调用test()
调用test()如果Father还有一个父类Person的话,new一个Son的时候,构造器的顺序是 Person()--Father()--Son()
其它情况,都是以些类推的
还可以加一些,变量,和重写的方法~~~这样便于你理解~~~创建一个对象的时候,初始化顺序

Answer 7

答：
1）真正的关键是：
public Father()
    {
        System.out.println("调用Father()");
    }
在编译时，真正的代码是：
public Father()
    {
        super();//这是编译程序自动加上的。
        System.out.println("调用Father()");
    }
及：
 public Son()
    {        
        System.out.println("调用Son()");
    }
在编译时，真正的代码是：
public Son()
    {        super();//这是编译程序自动加上的。
        System.out.println("调用Son()");
    }这才是：
“Java会自动在导出类构造器中插入对基类构造器的调用”这句话的真正含义。2）调用一次输出一次
3）构造器的调用与方法的调用原理上是一回事。若使用new 来调用的话，想调用多少次都可以。但用super()或this()只能调用一次。不可能写两个或多个super()或this()

Answer 8

你的理解是错误的 使用new 来调用的话构造器的调用与方法的调用原理上一样 在子类中 编译时加上了 super（）用new（）调用一次 他就执行一次

Answer 9

注意：father是Father的引用，但是指向son实例的

Answer 10

只有new的时候才会调用构造方法..
你这里是只会输出一次"调用Father()"的. 声明Father类型的变量,只是加载,初始化这个类,而并没有实例化阿..
而且建议LZ思考下这种向上转型会给你的程序带来什么好处和带来什么不好的?  

Answer 11

建议楼主DUBUG调试下，看下程序怎么运行的。

Answer 12

仅仅是引用了父类，并没有实例化，所以不会执行父类的构造方法！
然后实例化子类的时候，会自动调用了父类的构造方法，然后再调用了子类的构造方法，
所以仅输出一次
调用Father() 
调用Son() 
后面的不用说了，你肯定理解了！

Answer 13

UP楼上的所有同志.Father father = new Son();new Son() 会执行构造器super（），然后再Son（）。
Father father只是个引用，相当于个指针指向某个对象，不会执行构造器，他不会输出father()。
所以结果只有一个father()

Answer 14

  LZ问题可能没说清楚，各楼都有自己的不同理解，
    我猜你的问题是静态方法的问题吧，不然怎么调用两个test方法
  

Answer 15

我觉得楼主先好好的研究一下JAVA基础教程，详细的研究下JAVA构造函数的初始化过程，和析构函数。
JAVA里所有对象都是OBJECT的子类，而且OBJECT有一些大部分类都需要的通用方法。所以要实例化一个类，必须要先实例化他的父类，只是这个过程被JAVA来帮你完成了，他自动插入super()//初始化基类   这也很简单嘛，要有你必须要有你的父母，是吧，一个道理。他这个是一层一层来初始化的，如你的程序，father 和 son, son继承于father 而他的基类也是object，最后的初化过程是，初始化son调用son的构造函数，系统自动在son的构造函数里插入super()就是再调用father的构造函数，在father的构造函数里，又插入super()一直重复这个过程，直到object，当object被实例化在内存中，就又一次开始向后走，到father类时，执行他构造器里的内容，然后又到SON再执行他构造函数里面的内容