构造函数的调用问题

Question

Abstract class A{
    public A(){draw();}
    abstract draw();
}
class B extends A{
    public B(){}
    void draw(){}
}
public class Test{
    public static void main(String[] args){
        B b=new B();
    }
}
根据java里构造函数的递归调用过程，
1，B构造器构造对象的时候先调用A的构造器，
2，而A的构造器则会调用A的draw方法，
3，而B又是实现A的子类，则A的draw方法会调用B的draw方法，这时B又要调用A的构造器，
这样一来不是死循环了？不知道我这样理解对不对，

Answer 1

晕了...
B继承A(抽象类)
A里面出现的方法.B里都要继承下了.

Answer 2

3，而B又是实现A的子类，则A的draw方法会调用B的draw方法，这时B又要调用A的构造器，A的draw方法会调用B的draw方法后，A的构造过程就结束了啊。
然后B在开始完成剩下的构造过程就ok了。

Answer 3

楼上的说的有点道理,java中是不推荐构造器中调用其他函数的,不仅仅是抽象方法,因为这时类A还没初始化

Answer 4

则A的draw方法会调用B的draw方法，这时B又要调用A的构造器--A的方法并不是调用B的方法.而是一种override.
abstract class A{
    public A(){
draw();
System.out.println("A");
}
    abstract void draw();
}
class B extends A{
    public B(){}
    void draw(){
System.out.println("B");
}
}
public class test{
    public static void main(String[] args){
        B b=new B();
    }
}

Answer 5

这里应是这样的.
1，B构造器构造对象的时候先调用A的构造器，
2，而A的构造器则会调用A的draw方法，
3，这里调用A的draw时,因为B实现A(我觉的也是一种覆盖方法.)的方法.那它就会去执行B的方法,不会再构造一个B,因此就不会再去调用A的构造方法了.

Answer 6

而B又是实现A的子类，则A的draw方法会调用B的draw方法，这时B又要调用A的构造器是啊这句话有问题，函数写啊

Answer 7

B不是一个独立的类型，是基于A的扩展。构造B时，对A的构造是对B进行构造的必不可少的一部分。实际上，在构造B的时候，并没有类A的概念。在构造B时，其中对A的构造相当于是B在调用属于自身的一个方法，当然，这个方法比一般方法特殊一点。我把你的代码改变一下，我想你会明白。
public class TestConstructor {
public static void main(String[] args) {
B b = new B();
}
}abstract class A {
public A () {
System.out.println("A is constructing");
draw();
}
abstract void draw();
}class B extends A {
public B () {
// super(); // 构造子类时，这条语句总是默认执行。
System.out.println("B is constructing");
} void draw(){
System.out.println("B.draw");
}
}---------- 执行结果 ----------
// 首先默认执行super()
A is constructing
B.draw// 执行自身语句
B is constructing
------------------------------理解继承机制，记着把父类和子类扁平化。

Answer 8

我给你一种我的理解，仍然用UnAgain()的例子，他的例子很好。
首先，所有基类的构造方法在子类的构造方法中都会第一个被调用（隐式或显式），如果基类是一个具体类，那么在调用子类实例化时也会实例化一个基类对象；如果基类是一个抽象类，因为抽象类不允许生成实例，所以就算执行了super()，也不会生成抽象基类的实例。所以对于抽象基类构造方法的作用，主要是对基类进行一些必要的初始化，这样就减轻了子类初始化的工作量（我自己是这么理解的，不知道对不对）
楼住的困惑应该是来自于抽象类中的那个抽象方法draw()，你的问题是为什么基类构造器好像“看到了”子类的具体draw()方法了，其实就像UnAgain()朋友说的，理解继承机制，记着把父类和子类扁平化。楼住不妨这样看待这个B类：
class B extends A {
    public B () {
        System.out.println("A is constructing");
        draw();
        System.out.println("B is constructing");
    }    void draw(){
        System.out.println("B.draw");
    }
}
其实这样的模式就是对继承机制的一种应用，当然可能这种模式好像没什么实际意义。你在抽象基类构造器中调用这个具体方法真有什么具体应用价值？所以不建议。
还是应该在抽象基类中声明接口（抽象方法），在子类中根据子类的要实现的功能实现它，通过子类对象去调用，这是正常的模式。

Answer 9

abstract class A{
    public A(){
        System.out.println("contruct A");
        draw();
        System.out.println("exit A");
    }
    abstract void draw();
}
class B extends A{
    public B(){
    System.out.println(" contructor b");
    }
    void draw(){
    System.out.println("Class B");
    }
}
public class Test{
    public static void main(String[] args){
        B b=new B();
    }
}
结果是：
contruct AClass Bexit A contructor b

Answer 10

UnAgain() 和bryantd(Delphi菜鸟)讲的大致意思是不是说：B中调用的就是自己的draw方法，这样B构造的时候只要调用到A的构造器就可以了，
class B extends A {
    public B () {
        System.out.println("A is constructing");
        draw();   //这个就是自己的draw方法了？是吧？
        System.out.println("B is constructing");
    }    void draw(){
        System.out.println("B.draw");
    }
}
就像这样，恩，