黑马程序员技术交流社区

标题: java子类继承父类时的内存过程 请教 [打印本页]
作者: 506291315    时间: 2014-9-9 16:41
标题: java子类继承父类时的内存过程 请教
ublic class Test01 {

/**
* @param args
*/
public static void main(String[] args) {
B b=new B();
}
}

class A{
int num=5;
A(){
show();
}
public void show(){
  System.out.println("A"+num);
}
}

class B extends A{
int num=10;
B(){
     show();       
}
public void show(){
System.out.println("B"+num);
}
}
结果为：
B0
B10
求讲解
作者: hejinzhong    时间: 2014-9-9 21:35


  3. /**
  4. * 这个问题主要是理解对象初始化的顺序，同时注意隐式this
  5. */
  6. public class Test {
  7.        
  8.         //这里建立子类对象，下面数字代表执行顺序
  9.         public static void main(String[] args) {
  10.                 B b = new B(); //---------建立对象，走其构造----1
  11.         }
  12. }

  14. class A {
  15.         int num = 5;

  17.         A() {
  18.                 show(); //------子类对象调用this.show方法，由于子类覆写了。
  19.                 //所以走子类，同时子类中有自己num.
  20.                 //但这个时候，构造函数还未初始完，所以子类成员变量的值还是默认的0.------3
  21.         }

  23.         public void show() {
  24.                 System.out.println("A" + num);
  25.         }
  26. }
  27. /*
  28. * 构造函数初始化完，之后才到非静态成员变量的初始化。
  29. */

  31. class B extends A {
  32.         int num = 10;
  33.         B() {
  34.                 super();//--隐式super-----即在构造的时候先走父类---2
  35.                 show();
  36.         }
  37.         public void show() {
  38.                 System.out.println("B" + num);
  39.         }
  40. }
复制代码

作者: 爽朗的菜籽    时间: 2014-9-9 22:44

  2. public class ExtendsTest
  3. {
  4.         public static void main(String[] args)
  5.         {
  6.                 B b = new B();
  7.         }
  8. }

  10. class A
  11. {
  12.         int num = 5;
  13.        
  14.         A()
  15.         {
  16.                 show();
  17.         }
  18.        
  19.         public void show()
  20.         {
  21.                 System.out.println("A"+num);
  22.         }
  23. }

  25. class B extends A
  26. {
  27.         int num = 10;
  28.        
  29.         B()
  30.         {
  31.                 super();
  32.                 show();
  33.                 return;
  34.         }
  35.        
  36.         public void show()
  37.         {
  38.                 System.out.println("B"+num);
  39.         }
  40. }
复制代码

有看到我改的B的构造函数么，首先，你要明确 在子类中构造函数肯定会访问 父类的空参的构造函数（指定的父类的构造函数另当别论了），也就是 super()这一步，当A B 加载进内存时 在代码区域，你new了一个B 时会访问到A的空参的构造函数，这个时候堆内存中 B的情况 是 num并没有显示初始化，而是默认初始化，也就是说这个时候 B的 num 的值默认是 0，此时访问到的A的构造函数中调用了 show()方法，而在B中已经重写了A的此方法，也就是说其实调用的是B的show()方法，这个时候输出自然是 B0 了，只有当 super() 即父类初始化完毕了，才进行子类的成员变量的显示初始化， super() 就是一个分水岭，这一步结束了，num的值立刻就被显示初始化变成 10 （这一步的显示初始化紧紧跟着super()），之后再调用 show()，这就不用多说了吧， 输出 B10,是一定的啦。。呼呼，，
  真心欢迎大神指出理解中的错处，谢谢了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2