精华内容
下载资源
问答
  • Java类的初始化顺序

    2021-06-15 17:18:14
  • java类的初始化顺序

    2016-09-16 09:09:52
    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 = "父类--变量";
     protected int i = 9;
     protected int j = 0;
     // 静态初始化块
     static {
      System.out.println(p_StaticField);
      System.out.println("父类--静态初始化块");
     }
     // 初始化块
     {
      System.out.println(p_Field);
      System.out.println("父类--初始化块");
     }
    // 构造器
     public Parent() {
      System.out.println("父类--构造器");
      System.out.println("i=" + i + ", j=" + j);
      j = 20;

     }
    }

    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("子类--构造器");
      System.out.println("i=" + i + ",j=" + j);
     }
    // 程序入口
     public static void main(String[] args) {
      System.out.println("子类main方法");
      new SubClass();
     }
    }
    运行一下上面的代码,结果马上呈现在我们的眼前:
    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9, j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20
    现在,结果已经不言自明了。子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。
    静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

    执行过程分析

     (1)访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    (2)执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    (3)当所有必要的类都已经装载结束,开始执行main()方法体并用new SubClass()创建对象。

    (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数(也就是Beetle()构造函数所做的第一件事)。

    基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    展开全文
  • Java 类的初始化顺序

    2019-11-26 08:57:44
    Java 类的初始化顺序 Java类的初始化顺序是:父类静态代码块——>子类静态代码块——>父类非静态代码块——>父类构造器——>子类非静态代码块——>子类构造器。 测试代码: 首先是父类A public ...

    Java 类的初始化顺序

    Java中类的初始化顺序是:父类静态代码块——>子类静态代码块——>父类非静态代码块——>父类构造器——>子类非静态代码块——>子类构造器。

    测试代码:
    首先是父类A

    public class A {
    	
    	public A() {
    		System.out.println("父类的构造器");
    	}
    	
    	static {
    		System.out.println("父类的静态代码块");
    	}
    
    	{
    		System.out.println("父类非静态代码块");
    	}
    	
    }
    

    子类B继承父类A

    public class B extends A{
    	
    	public B(){
    		System.out.println("子类的构造器");
    	}
    	
    	static {
    		System.out.println("子类的静态代码块");
    	}
    	
    	{
    		System.out.println("子类的非静态代码块");
    	}
    	
    	public static void main(String[] args) {
    		B b = new B();
    	}
    }
    

    运行结果如下:
    在这里插入图片描述

    展开全文
  • JAVA类的初始化顺序

    2016-01-19 22:24:07
    java类的初始化顺序是面试中常问到的一个问题,下面通过一个加载例子就可以让我们深入了解java类的加载顺序,而不是死记硬背。 先定义一个父类Fatherpublic class Father { public static String str1 = "Father...

    java类的初始化顺序是面试中常问到的一个问题,下面通过一个加载例子就可以让我们深入了解java类的加载顺序,而不是死记硬背。
    先定义一个父类Father

    public class Father {
        public static String str1 = "Father静态字符串";
        public String str2 = "Father普通字符串";
    
        static {
            System.out.println(str1);
            System.out.println("Father 静态代码块2");
        }
    
        static {
    
            System.out.println("Father 静态代码块1");
        }
    
        {
            System.out.println(str2);
            System.out.println("Father 代码块2");
        }
    
        {
    
            System.out.println("Father 代码块1");
        }
    
        public Father(){
            System.out.println("Father 构造器");
        }
    }

    然后定义一个子类child并继承父类

    public class child extends Father{
        public static String str1 = "Child静态字符串";
        public String str2 = "Child普通字符串";
        static {
            System.out.println(str1);
            System.out.println("Child 静态代码块2");
        }
    
        static {
    
            System.out.println("Child 静态代码块1");
        }
    
        {
            System.out.println(str2);
            System.out.println("Child 代码块2");
        }
    
        {
    
            System.out.println("Child 代码块1");
        }
    
        public child(){
            System.out.println("Child 构造器");
        }
    }
    

    测试函数

    public class test {
        public static void main(String[] args) {
            Father a= new child();
        }
    }

    测试结果
    这里写图片描述

    下面就讲解一下背后的原理
    1.main方法启动后,类加载器就会加载child.class类,在加载过程中发现他有父类,则会先加载父类。加载完后先去执行father的静态代码区,执行完后再执行子类的静态代码区。静态代码区按顺序执行。
    2.当静态代码区执行完后,开始创建对象,new对象(在方法区中为对象分配空间)。由于子类中含有this.super()方法,所以先创建父类对象,在创建时会加载父类的非静态区的对象与方法,加载完后再加载父类的构造方法。
    3.加载完父类的构造方法后再加载子类的非静态对象与方法,最后执行子类构造器。

    所以总结一下,java初始化顺序:
    父类静态对象与静态代码块
    子类静态对象与静态代码块
    父类非静态对象与非静态代码块
    父类构造器
    子类非静态对象与非静态代码块
    子类构造器

    展开全文
  • JAVA 类的初始化顺序

    2020-02-14 16:27:23
    先初始化静态变量和静态代码块(静态变量和静态代码块的初始化顺序按照在中的先后顺序), 然后再初始化非静态变量和非静态代码块(非静态变量和非静态代码块之间也是按照在中的先后顺序), 如果非静态变量未...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,264
精华内容 2,105
关键字:

java类的初始化顺序

java 订阅