java初始化块（2）_a a=new b()构造代码块-CSDN博客

本文链接：https://blog.csdn.net/qq_34746239/article/details/93381028

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

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

3、执行顺序：父类static -》子类static-》父类非static-》父类构造-》子类非static-》子类构造

4、对于new A(new B());先执行A的static，在执行B的所有，最后执行A的非静态和构造

举例：

1、无继承，无层次

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

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

3、(1)无继承，有层次

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();
	}
}

结果：先按照规则执行A的静态化块，在A的静态化块里先执行new B（）；所以执行完B的静态、非静态、构造之后才会继续执行A静态化块里剩余的，然后执行A的非静态和构造。

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

3、(2)

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();
	}
}

结果分析：new A（）；-》

1、执行A的静态化块

（1）new A();-》

1>A的静态化块只执行一次，在外层执行过了，所以在内层跳过

2>执行A的非静态化块

3>执行A的无参构造函数

（2）System.out.println("a-static1");

（3）System.out.println("a-static2");

2、执行A的非静态化块

3、执行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

4、有层次有继承

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 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();
	}
}

结果分析：

new A（）；-》

1、执行A的static

（1）new B(); B为A的子类-》

1>A的static在外层执行过了，所以跳过

2>执行B的static

3>执行A的非static

4>执行A的构造

5>执行B的非static

6>执行B的构造

（2）System.out.println("a-static1");

（3）System.out.println("a-static2");

2、执行A的非static

3、执行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

5、将层次放在构造函数中 --》 new A(new B());先执行A的static，在执行B的所有，最后执行A的非静态和构造

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());
	}
}

结果分析：

1、执行Class1的静态代码块

(1)new Class2(); -->Class2继承了Class1

Class1的静态执行过了，跳过

执行Class2的静态

执行Class1的非静态

执行Class1的构造

执行Class2的非静态

执行Class2的构造

(2)System.out.println("666666666666666666");

2、执行Class3的所有 -》Class3传递继承Class1（因为Class2没有任何信息，所以直接忽略）

Class1的静态执行过了，跳过

执行Class3的静态

执行Class1的非静态

执行Class1的构造

执行Class3的非静态

执行Class3的构造

3、执行Class1的非静态代码块

4、执行Class1的有参构造方法

结果如下：

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