大家看看这个程序把!(弄懂接结分)

Question

构造方法只有在对象实例化的时候才被调用所以，调用过程是B()->B(int i)->A(int i)->A()，在A(int i)完了之后，开始初始化B中的field，执行初始化块，最后回到B(int i)->B()，这样，一个B的实例对象生成了。

Answer 1

Jumperr(一盒子的新鲜蔬菜) 
我还不太清楚你的意思
用过程是B()->B(int i)->A(int i)->A()，在A(int i)完了之后，开始初始化B中的field，执行初始化块，最后回到B(int i)->B()有的模糊
请指教!

Answer 2

new B() -> B.B() -> A.A()[output line 1]
this(10) -> B.B(int) -> A.A(int)[output line 2]
B.f() [output line 3]
..........

Answer 3

B bobj = new B();//当然先调用B()构造方法，但是他又调用了
B(int i)方法，而且，在此B(int i)方法中，调用了A(int i)方法，在A(int i)方法中调用了
A()方法
因此先输出：A.A called //即先执行A()方法
接着执行了A(int i)方法，输出了 A.A(int) called
在下面的输出，就是自己的类的构造了，需要从B的开始出执行，就是int i = f();
这一步，输出   B.f called
接着往下执行，输出了 initialization block executed
这样，此类的内部变量都生成后，就要返回到
B(int i) {
super(i);
System.out.println("B.B(int) called");//<<<<<<-----这一步了
}
就输出了  B.B(int) called
然后返回到了调用此构造方法的B()了
接着输出的 就是B.B() called 了

Answer 4

哦,终于明白了!谢谢!
我总结以下看对不对:
对一个子类进行初始话,先调用他的构造法,但调子构造法前还得先掉用父构造法,调完后,回到子类先把自己的变量初始话之后才再调用自己的构造法(自己的构造法非得最后调用吗,如果在它的后面还有需要被初始话的对象呢?),这样才完成对对象的初始话.由于在里面的构造法不少,我再想问一下:
如果把上面程序中的super(i)去掉,应该也可以吧??他回自己调用父类的构造法吧.
如果把this()去掉呢?
"因此先输出：A.A called //即先执行A()方法
接着执行了A(int i)方法，输出了 A.A(int) called"
这里如果A还有构造法呢,是不是所有的都要执行,如果这样的话,他们的顺序呢?

Answer 5

理解的大概差不多
不过，如果不用super()，会调用父类构造子吗？试一下看看吧
还有，就是先调用子类本身的构造子，是构造子里调用了父类的构造子

Answer 6

这其中还包括overload和override的区别
找本基础的书看看概念吧

Answer 7

B bobj = new B();===>B()
====>B(){this(10)}====>B(i)===>B(i){super(i)}
===>A(int i){this();}===>A(){System.out.println("A.A called");}
===>A(i){System.out.println("A.A(int) called");}
===>int i = f();==>int f(){System.out.println("B.f called");return 47;}
===int j;===>{j=37;System.out.println("initialization block executed");}
===>B(int i){System.out.println("B.B(int) called");}
===>B(){System.out.println("B.B() called");}

Answer 8

大家可以把B(){}里面的this(10);这句注释掉，会发现调用A()的时间会发生变化，他会在进入B的构造函数体之前先去执行A的构造函数，而不是先进入B的构造函数执行this(10);这一句话。

Answer 9

overload和override是什么??
看样子我还要加把劲啊!!!!!!!

Answer 10

huqingmiao(小满) 
有道理!?
比我强!~~~

Answer 11

我觉得很明白呀，就是一层一层的找呗，由下到上，子类构造还要先构造父类？有这么麻烦，那要super()干什么用；建议还使用个顺序图表示吧，呵呵

Answer 12

顺序是这样的！
  B()->this(10)->B(i)->super(i)->A(i)->this()->A()->f()

Answer 13

上面的我也大概清楚了,请兄弟门帮我看看这:
由于在里面的构造法不少,我再想问一下:
如果把上面程序中的super(i)去掉,应该也可以吧??他回自己调用父类的构造法吧.
如果把this()去掉呢?
"因此先输出：A.A called //即先执行A()方法
接着执行了A(int i)方法，输出了 A.A(int) called"
//这里如果A还有构造法呢,是不是所有的都要执行,如果这样的话,他们的顺序呢?
还有一个程序:
class A {A(){}int a = f();int f() {return 1;}} class B extends A {B(){super();}
int b = a;int f() {return 2;}} public class CtorDemo1 {public static void main(String args[]) {B bobj = new B();System.out.println(bobj.b);}}由于没有构造法,它编译的时候会自动加的应该如下:
class A {int a = f();int f() {return 1;}} class B extends A {int b = a;int f() {return 2;}} public class CtorDemo1 {public static void main(String args[]) {B bobj = new B();System.out.println(bobj.b);}}
由于这两个构造法都没有什么实际语句,然后它是怎么初始化的呢?
答案是：bobj.b 的值是2它是把A的int a = f();执行了?为什么?有没有兄弟帮我总结一下初始化程序的原则!

Answer 14

上面的那个问题是这个样子的,当生成B类的一个对象的时候,如果B类是别的类的子类,那么初始化过程就要转到B类的超类中进行初始化,不过B类中的方法f()将超类A中的方法f()覆盖上,所有在超类A中进行int a=f()时,实际上是调用的B类中的f(),所以最后结果是2

Answer 15

不过B类中的方法f()将超类A中的方法f()覆盖上,所有在超类A中进行int a=f()时,实际上是调用的B类中的f()//它不属于构造方法也要调用吗?

Answer 16

super的作用在这里可以看作是参数传递给父类的构造函数，但是实际上是执行父类初始化

Answer 17

建议楼主去看看:override 就明白其中道理拉！

Answer 18

override 是关于什么方面的
你们知道哪里有这方面的资料吗?

Answer 19

“不过B类中的方法f()将超类A中的方法f()覆盖上,所有在超类A中进行int a=f()时,实际上是调用的B类中的f()//它不属于构造方法也要调用吗?”——这里是为了初始化B中的ioverride是覆写，重写超类中的方法，面向对象的基本特征之一

Answer 20

好多人啊 我看我就up 一下算了 hoho~