Java子类与父类的初始化,父类子类內部程序的执行顺序

时间:2021-06-30 19:48:10
  1. 声明:本文出自:安卓开发网 
  2. class Parent{   
  3.     
  4.            int x=10;   
  5.            public Parent(){   
  6.                 add(2);   
  7.            }   
  8.            void add(int y){   
  9.                 x+=y;   
  10.            }   
  11.      }   
  12.   
  13.      class Child extends Parent{   
  14.           int x=9;   
  15.          void add(int y){   
  16.                x+=y;   
  17.           }   
  18.           public static void main(String[] args){   
  19.                Parent p=new Child();   
  20.                System.out.println(p.x);   
  21.           }    
  22.      }   

  问输出结果是什么? 
     答案应该是10。 
     要理解结果为什么是10,需要首先明白下面的知识: 
     (1)方法和变量在继承时的隐藏与覆盖 
     隐藏:若B隐藏了A的变量或方法,那么B不能访问A被隐藏的变量或方法,但将B转换成A后可以访问A被隐藏的变量或者方法。 
     覆盖:若B覆盖了A的变量或者方法,那么不仅B不能访问A被覆盖的变量或者方法,将B转换成A后同样不能访问A被覆盖的变量或者方法。 
     (2)Java中变量与方法在继承中的隐藏与覆盖规则: 
          一、父类的实例变量和类变量能被子类的同名变量隐藏。 
          二、父类的静态方法被子类的同名静态方法隐藏,父类的实例方法被子类的同名实例方法覆盖。 
          三、不能用子类的静态方法隐藏父类的实例方法,也不能用子类的实例方法覆盖父类的静态方法,否则编译器会异常。 
          四、用final关键字修饰的最终方法不能被覆盖。 
          五、变量只能被隐藏不会被覆盖,子类的实例变量可以隐藏父类的类变量,子类的类变量也可以隐藏父类的实例变量。 
     在上面的试题中,子类Child的实例方法add(int y)覆盖了父类Parent的实例方法add(int y),而子类的实例变量x则是隐藏了父类的实例变量x。 
     Child对象的初始化过程是: 
     首先为父类的实例变量x分配内存空间,因为在定义变量x时为它赋了值(int x=10),所以会同时将这个值赋给x。 
     其次调用父类的无参构造函数,Parent的构造函数中做的唯一的事情就是调用了add(2); 
     第三、由于子类的add(int y)方法覆盖了父类的方法,所以add(2)实际调用的是子类的方法,在子类的add方法中做了如下操作x+=j;在这里由于子类的实例变量x隐藏了父类 的实例变量x,所以这条语句是针对子类本身的,但是这时还没有为子类的实力变量x分配空间,它的默认值是0,加2之后是2。 
     第四、父类初始化完毕后接着初始化子类,为子类的x分配内存空间并将它赋值为9,之前的add(2)操作白瞎了。 
     再次注意Parent p=new Child();这条语句,它是用父类的引用指向子类的对象,而前面已经说过变量只会被隐藏不会被覆盖,所以这时的p.x值应该是父类的10,而不是子类的9; 
     如果将输出语句换成下面的语句结果就是9了: 
     System.out..println(((Child)p).x); //首先将p转换成Child类型 

原文:http://www.cnblogs.com/binjoo/articles/1585342.html

声明:本文出自:安卓开发网 


下以文章出自:http://blog.sina.com.cn/s/blog_6cea21730100ytuh.html

之前一致沒有認真研究這個問題,今天在研究JAVA類加載順序時突然想好好地研究研究。實驗總結如下:

step 1.父類的靜態成員和靜態塊(靜態變量和靜態塊屬同一級,自上而下執行)

step 2.子類的靜態成員和靜態塊(靜態變量和靜態塊屬同一級,自上而下執行)

step 3.父類的成員賦值和初始化塊和無static 的final成員成員 (同一級,自上而下執行)

step 4.父類的構造方法

step 5.父類構造方法中的其它語句

step 6.子類的成員賦值和初始化塊和無static 的final成員成員(同一級,自上而下執行)

step 7.子類的構造方法

step 8.子類構造方法中的其它語句

 

eg.

public class Test3 {
    public Test3(int num){
        System.out.println("Test3構造方法:"+num);
    }
}

 

public class Test1 {
    public  static Test3 test3=new Test3(5);
    public Test3 test4=new Test3(6);

    static{
        System.out.println("static Test1");
    }
    {
        System.out.println("no static Test1 ");
    }

    public Test1(){
        System.out.println("Test1構造方法");
    }
}

 

public class Test2 extends Test1 {     
    static{
        System.out.println("static Test2");
    }
  
    {
          System.out.println(" no static Test2");
    }
    private Test3 test4=new Test3(4);
    private static Test3 test3=new Test3(3);
    public Test2(){
        System.out.println("Test2構造方法");
    }
    public static void main(String[] args){
        Test2 test2=new Test2();
    }

}

 

執行結果:

Test3構造方法:5
static Test1
static Test2
Test3構造方法:3
Test3構造方法:6
no static Test1
Test1構造方法
 no static Test2
Test3構造方法:4


public class testjava
{
public static void main(String [] args)
{
child c = new child();
}
}

class child extends father
{
    int i = 10;

    public child()
{
        super();
        System.out.println(i);
    }

    public void prt()
{
        System.out.println("in child i = " + i + " k = " + k);
    }
}

abstract class father
{
    protected int k = 5;

    public father()
{
        prt();
    }
    public void prt()
{
        System.out.println("in father k = " + k);
    }
}

该测试程序输出的结果为
in child i = 0 k = 5
10

為什麼是運行child中的prt方法呢?

子类里面覆盖了父类的prt方法。父类发现你子类覆盖了他的方法,所以在父类里面调用的时候还是调用子类的方法了

為什麼i=0?

因為在運行prt方法時i還沒有初始化值,因此使用默認值。也許你又要問那i什麼時候初始化,具體執行順序請看上一篇文章http://blog.sina.com.cn/s/blog_6cea21730100ytt7.html

注:在加載class文件的時候會有一個准備的過程,在這過程中會為成員變量開辟一定的內存空間,並初始化默認值.因此在調用i的時候會是0