java类初始化顺序

本篇复习一下关于java类初始化的顺序,温故而知新还是很有道理的。

下面是java类初始化的顺序:

(静态变量、静态初始化块)>(变量、初始化块)>构造器

下面通过几个比较简单的例子来验证。

下面是解决了在单个类中成员初始化的顺序:

    public class InitialOrderTest {   
      
        // 静态变量   
        public static String staticField = "静态变量";   
        // 变量   
        public String field = "变量";   
      
        // 静态初始化块   
        static {   
            System.out.println(staticField);   
            System.out.println("静态初始化块");   
        }   
      
        // 初始化块   
        {   
            System.out.println(field);   
            System.out.println("初始化块");   
        }   
      
        // 构造器   
        public InitialOrderTest() {   
            System.out.println("构造器");   
        }   
      
        public static void main(String[] args) {   
            new InitialOrderTest();   
        }   
    }  
运行以上代码,我们会得到如下的输出结果:
  1. 静态变量
  2. 静态初始化块
  3. 变量
  4. 初始化块
  5. 构造器

下面代码验证了父类和子类的初始化顺序:

    class Parent {   
        // 静态变量   
        public static String p_StaticField = "父类--静态变量";   
        // 变量   
        public String p_Field = "父类--变量";   
      
        // 静态初始化块   
        static {   
            System.out.println(p_StaticField);   
            System.out.println("父类--静态初始化块");   
        }   
      
        // 初始化块   
        {   
            System.out.println(p_Field);   
            System.out.println("父类--初始化块");   
        }   
      
        // 构造器   
        public Parent() {   
            System.out.println("父类--构造器");   
        }   
    }   
      
    public class SubClass extends Parent {   
        // 静态变量   
        public static String s_StaticField = "子类--静态变量";   
        // 变量   
        public String s_Field = "子类--变量";   
        // 静态初始化块   
        static {   
            System.out.println(s_StaticField);   
            System.out.println("子类--静态初始化块");   
        }   
        // 初始化块   
        {   
            System.out.println(s_Field);   
            System.out.println("子类--初始化块");   
        }   
      
        // 构造器   
        public SubClass() {   
            System.out.println("子类--构造器");   
        }   
      
        // 程序入口   
        public static void main(String[] args) {   
            new SubClass();   
        }   
    }  

运行一下上面的代码,结果马上呈现在我们的眼前:
  1. 父类--静态变量
  2. 父类--静态初始化块
  3. 子类--静态变量
  4. 子类--静态初始化块
  5. 父类--变量
  6. 父类--初始化块
  7. 父类--构造器
  8. 子类--变量
  9. 子类--初始化块
  10. 子类--构造器

下面验证了静态变量和静态初始化块之间、变量和初始化块之间的先后顺序:

    public class TestOrder {   
        // 静态变量   
        public static TestA a = new TestA();   
           
        // 静态初始化块   
        static {   
            System.out.println("静态初始化块");   
        }   
           
        // 静态变量   
        public static TestB b = new TestB();   
      
        public static void main(String[] args) {   
            new TestOrder();   
        }   
    }   
      
    class TestA {   
        public TestA() {   
            System.out.println("Test--A");   
        }   
    }   
      
    class TestB {   
        public TestB() {   
            System.out.println("Test--B");   
        }   
    }  

运行上面的代码,会得到如下的结果:
  1. Test--A
  2. 静态初始化块
  3. Test--B
代码是引用的别人的(自己比较懒),例子是很好理解。



展开阅读全文

没有更多推荐了,返回首页