Java 类的实例变量初始化的过程 静态块、非静态块、构造函数的加载顺序

先看一道Java面试题：

 

public class Baset {
    private String baseName = "base";
    // 构造方法
    public Baset() {
        callName();
    }
    // 成员方法
    public void callName() {
        // TODO Auto-generated method stub
        System.out.println("basename:" + baseName);
    }
  //静态内部类
    static class Sub extends Baset {//static必须写在开头
        // 静态字段
        private String baseName = "sub";
        public Sub() {
            callName();
        }
        // 重写父类的方法
        public void callName() {
            System.out.println("subname:" + baseName);
        }
    }

    public static void main(String[] args) {
        Baset base = new Sub();
    }
}

 

求这段程序的输出。

解答此题关键在于理解和掌握类的加载过程以及子类继承父类后，重写方法的调用问题：

一、从程序的执行顺序去解答：

1.编译；当这个类被编译通知后，会在相应的目录下生成两个.class 文件。一个是　Base.class,另外一个就是Base$Sub.class。这个时候类加载器将这两个.class  文件加载到内存

2、Base base= new Sub()：

　　声明父类变量base对子类的引用，JAVA类加载器将Base,Sub类加载到JVM（Java虚拟机）;

3、JVM为Base,Sub 的的成员开辟内存空间

　　此时，Base 和Sub类中的值为null;

4、new Sub()；

　　这个时候会调用Sub类的隐式构造方法，

     Sub的构造方法本质为：

     public Sub(){

　　super();//  调用父类的构造方法。必须在构造方法中的第一行，为什么呢？这是因为在一些程序的升级中，要兼容旧版本的一些功能，父类即原先的一些初始化信息也要保证  //被执行到，然后执行当前

　　baseName = "sub";//子类字段初始化

      }

    new Sub()执行到super()这行代码也就是跑到父类中去执行了，我们跳转到父类中的无参构造方法中执行，最后执行Sub()中的baseName = "sub"

5、public Base() ；

      父类无参构造方法的本质为：

　　public Base(){

　　baseName= "base";//父类字段初始化

　　callName();

    }

　　即将父类的baseName赋值为“base”,赋值后调用callName();

6、callName()方法在子类中被重写，因此调用子类的callName()，子类的callName方法执行，打印输出的是子类的baseName 字段的值，而这个时候子类的构造函数中字段的赋值还未执行。

7、父类的构造函数执行完毕，这个时候又回到子类当中，从super()的下一行继续执行，这个时候才为子类字段baseName 分配好存储空间，随后为其赋值：

 可见，在baseName = "sub"执行前，子类的callName()已经执行，所以子类的baseName为默认值状态null;

 二、另写两个程序，进行更具体的分析

 1、第一个程序：

public class InitialOrderTest {
//    变量
    public String field = "变量";
//  静态变量
    public  static  String staticField="静态变量";
//父类静态方法    
    public static void Order(){
        System.out.print("父类静态方法");
        System.out.println("staticField:"+staticField);
    }

//  静态初始代码块
    static{
        System.out.println("静态初始化块");
           System.out.println("staticField:"+staticField);
       }
//   初始化代码块  
      {
          System.out.println("初始化代码块");
          System.out.println("field:"+field);
       }
//   构造函数
   public InitialOrderTest(){
       System.out.println("构造器");
       
   }
 
   public static void main(String[] args) {
       System.out.println("-----[[-------");
       System.out.println(InitialOrderTest.staticField);
       InitialOrderTest.Order();
       System.out.println("------]]------");
       InitialOrderTest i = new InitialOrderTest();
       System.out.println("-----[[-------");
       System.out.println(InitialOrderTest.staticField);
       InitialOrderTest.Order();
       System.out.println("------]]------");
      
   }
}

执行结果为：

   第一个程序总结：

     1)、java中的块分为静态块（static{}）和非静态块（{}），这两种的执行是有区别的：

        非静态块的执行时间是：在执行构造函数之前。   静态块的执行时间是：class文件加载时执行。

        static类型的属性也是在类加载时执行的。

    2)、可见Java类的实例变量初始化的过程：

        static类型的成员属性执行，静态块（static{})按顺序执行，然后非静态成员变量初始化，非静态代码块（{}）执行，最后执行构造方法。

       static类型与static块按先后顺序执行。

---------------------------------------------------------------------------------------------------------------------------------------------------

  2、第二个程序：

   

public class BaseTest {
    // 父类变量
    private String baseName = "base";
    // 父类静态变量
    private static String staticField = "父类静态变量";
    // 父类静态方法
    public static void Order() {
        System.out.println("父类静态方法-");
        System.out.println("staticField:" + staticField);
    }
    // 父类静态初始代码块
    static {
        System.out.println("父类静态初始化代码块-");
        System.out.println("staticField:" + staticField);
    }
    // 初始化代码块
    {
        System.out.println("父类非静态初始化代码块-");
        System.out.println("baseName:" + baseName);
    }
    // 构造函数
    public BaseTest() {
        System.out.println("父类构造方法");
        callName();
    }
    // 成员方法
    public void callName() {
        System.out.println("父类callName方法-");
        System.out.println("baseName:" + baseName);
    }

    // 静态内部类
    static class Sub extends BaseTest {
        // 子类变量
        private String baseName = "sub";
        // 子类 静态变量
        private static String staticField = "子类静态变量";

        // 子类静态方法
        public static void Order() {
            System.out.println("子类静态方法-");
            System.out.println("staticField:" + staticField);
        }

        // 子类静态初始化代码块
        static {
            System.out.println("子类静态初始化代码块-");
            System.out.println("staticField:" + staticField);
        }
        // 子类非静态初始化代码块
        {
            System.out.println("子类非静态初始化代码块-");
            System.out.println("baseName:" + baseName);
        }

        public Sub() {
            System.out.println("子类构造方法");
            callName();
        }

        public void callName() {
            System.out.println("子类重写父类callName方法-");
            System.out.println("baseName:" + baseName);
        }
    }

    public static void main(String[] args) {
        
        BaseTest b = new Sub();

        System.out.println("-----[[-------");
        Sub.Order();
        System.out.println(Sub.staticField);
        System.out.println(BaseTest.staticField);
        BaseTest.Order();
        System.out.println("------]]------");

    }
}

 

  执行结果：

  

第二个程序总结：

     1)、可见Java初始化的顺序：   

 1 父类静态代码块-static{ }
 2 父类静态变量初始化
 3 子类静态代码块-static{ }
 4 子类静态变量初始化
 5 父类非静态代码块-{}
 6 父类非静态变量初始化
 7 父类构造方法
 8 子类非静态代码块-{}
 9 子类非静态变量初始化
10 子类构造方法