暂无图片
暂无图片
暂无图片
暂无图片
暂无图片
首页 / 实践探索JAVA初始化过程

实践探索JAVA初始化过程

大学生IT学习之家 2019-07-11
267

1.JAVA在初始化的时候首先初始化静态代码块（只执行一次），然后非静态代码块，然后构造方法。

2.在各个代码块中顺序执行。

3.在存在继承关系的时候顺序为：父类static -> 子类static -> 父类非static  ->  父类构造方法 -> 子类非static ->子类构造方法。

无继承，无层次：

public class A {
  static {
    System.out.println("a-static1");
    System.out.println("a-static2");
  }
  {
    System.out.println("a-not-static1");
    System.out.println("a-not-static2");
  }
  public A() {
    System.out.println("A构造方法1");
    System.out.println("A构造方法2");
  }


        public static void main(String[] args) {
    A a = new A();
  }
}
}


执行结果：

a-static1
a-static2
a-not-static1
a-not-static2
A构造方法1
A构造方法2

与设想一样，静态非静态然后构造函数，各代码块顺序执行。

有继承，无层次：

public class A {
  static {
    System.out.println("a-static1");
    System.out.println("a-static2");
  }
  {
    System.out.println("a-not-static1");
    System.out.println("a-not-static2");
  }
  public A() {
    System.out.println("A无参构造方法1");
    System.out.println("A无参构造方法2");
  }
  
  public A(B b) {
    System.out.println("A有参构造方法1");
    System.out.println("A有参构造方法2");
  }
}

public class B extends A{
  static {
    System.out.println("B-static");
  }
  {
    System.out.println("B-not-static");
  }
  public B() {
    System.out.println("B-construct");
  }
}


public class Test {
public static void main(String[] args) {
    new B();
  }
}


执行结果：

a-static1
a-static2
B-static
a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2
B-not-static
B-construct

无继承，有层次：

public class A {
  static {
    new B();
    System.out.println("a-static1");
    System.out.println("a-static2");
  }
  {
    System.out.println("a-not-static1");
    System.out.println("a-not-static2");
  }
  public A() {
    System.out.println("A无参构造方法1");
    System.out.println("A无参构造方法2");
  }
  
  public A(B b) {
    System.out.println("A有参构造方法1");
    System.out.println("A有参构造方法2");
  }
}
public class B {
  static {
    System.out.println("B-static");
  }
  {
    System.out.println("B-not-static");
  }
  public B() {
    System.out.println("B-construct");
  }
}


public class Test {
public static void main(String[] args) {
  new A();
  }
}

执行结果：

B-static
B-not-static
B-construct
a-static1
a-static2
a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2

按照规律先执行A的static块，初始化完B（）才会去接着执行。


再来一个例子：

public class A {
  static {
    new A();
    System.out.println("a-static1");
    System.out.println("a-static2");
  }
  {
    System.out.println("a-not-static1");
    System.out.println("a-not-static2");
  }
  public A() {
    System.out.println("A无参构造方法1");
    System.out.println("A无参构造方法2");
  }
  
  public A(B b) {
    System.out.println("A有参构造方法1");
    System.out.println("A有参构造方法2");
  }
}
public class Test {
public static void main(String[] args) {
  new A();
  }
}


结果：

a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2
a-static1
a-static2
a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2

先去执行A的static块，然后static块中有new A()的操作，所以去执行，但是static块已经被初始化了，所以不执行，执行非静态代码块和构造函数，执行完static块中的new A()操作了，然后接着执行。。。（省略）


如果我的层次放在构造函数中会怎么样？

public class A {
  static {
    System.out.println("a-static1");
    System.out.println("a-static2");
  }
  {
    System.out.println("a-not-static1");
    System.out.println("a-not-static2");
  }
  public A() {
    System.out.println("A无参构造方法1");
    System.out.println("A无参构造方法2");
  }
  
  public A(B b) {
    System.out.println("A有参构造方法1");
    System.out.println("A有参构造方法2");
  }
}
public class B {
  static {
    System.out.println("B-static");
  }
  {
    System.out.println("B-not-static");
  }
  public B() {
    System.out.println("B-construct");
  }
}



public class Test {
public static void main(String[] args) {
  new A(new B());
  }
}


执行结果：

a-static1
a-static2
B-static
B-not-static
B-construct
a-not-static1
a-not-static2
A有参构造方法1
A有参构造方法2


这个结果看的我有点吃惊，他首先执行A的static块这是没有问题的，但是后边在执行非static块之前先去把B整个初始化的流程给执行完了，然后再执行下面步骤。由于本人水平有限，暂时无法解释到虚拟机底层的流程到底是怎么执行的。还希望大佬们不吝赐教。

有层次，有继承：

public class B extends A{
  static {
    System.out.println("B-static");
  }
  {
    System.out.println("B-not-static");
  }
  public B() {
    System.out.println("B-construct");
  }
}
public class Test {
public static void main(String[] args) {
  new A();
  }
}

执行结果：

B-static
a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2
B-not-static
B-construct
a-static1
a-static2
a-not-static1
a-not-static2
A无参构造方法1
A无参构造方法2

与我们的逻辑无误。首先A去初始化，在static块中遇到了new B(),B又是A的子类，那B先去初始父类A,但是A的static块已经被执行过了。然后执行子类static块，然后父类非静态代码块以及构造方法，然后子类非静态代码块以及构造方法，然后Astatic块中的new B()就执行完了，然后顺序打印2个语句，然后就是A的非静态块以及构造方法了。


最后来分析一个困扰我2天例子：

public class Class1 {
  
  static {
    new Class2();
    System.out.println("666666666666666666");
  }
  {
    System.out.println("99999999999999999");
  }
  
  
  public Class1() {
    
    System.out.println("111111111111111111111");
  }
  
  public Class1(Class1 c1){
    System.out.println("==============");
  }
  
  public Class1(Class2 c2){
    System.out.println("++++++++++++++++++++");
  }
  
  public Class1(Class3 c3){
    System.out.println("---------");
  }


}
public class Class2 extends Class1{


}
public class Class3 extends Class2{


}
public class Test {
public static void main(String[] args) {
    new Class1(new Class3());
  }
}




执行结果：

99999999999999999
111111111111111111111
666666666666666666
99999999999999999
111111111111111111111
99999999999999999
---------


分析：

java
文章转载自大学生IT学习之家，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

评论