java类执行顺序

首先假设有如下的一些辅助类，这些类被其他类使用作为静态变量或非静态变量： 

public class C {
    public C() {
        System.out.println("C");
    }
}

public class E {
    public E() {
        System.out.println("E");
    }
}

public class F {
    public F() {
        System.out.println("F");
    }
}

public class G {
    public G() {
        System.out.println("G");
    }
}


public class H {
    public H() {
        System.out.println("H");
    }
}

1)继承自Object的类的构造函数的执行顺序： 
假设有如下的一个类I,I的定义如下： 

public class I {
public G g = new G();//6
public static E statice0 = new E();//1
static {//2
statice0 = new E();
System.out.println("判断static执行的顺序");
}
public static E statice1;
public static F f1;
static {//3
System.out.println("测试在static块中执行的顺序1");
statice1 = new E();
f1 = new F();
}
static {//4
System.out.println("测试在static块中执行的顺序2");
f1 = new F();
statice1 = new E();
}
public static H h = new H();//5
public E e;//7
{
System.out.println("aaa");
e = new E();
}
public I(int i) {//8
statice0 = new E();
f1 = new F();
e = new E();
}
public static void main(String[] args) {
I i = new I(1);
}
}

执行结果： 
E 
E 
判断static执行的顺序 
测试在static块中执行的顺序1 
E 
F 
测试在static块中执行的顺序2 
F 
E 
H 
G 
aaa 
E 
F 
H 
E 
从这个结果来可以知道，从Object派生的类将会按照如下的书序执行： 
    1、静态变量，如果有静态块的话，则按照静态块中变量new的顺序执行静态变量构造函数。如果没有静态块的话，则按照声明的顺序执行。 
    2、非静态变量，如果有非静态变量初始化块的话，则按照new的顺序执行构造函数，如果没有初始化块则按照声明的顺序执行。 
    3、执行构造函数，所有的变量按照new的顺序执行构造函数。 

 

 

------------------------------------分割线-------------------------------------------------   

  

java类执行顺序

 

如果父类有静态成员赋值或者静态初始化块，执行静态成员赋值和静态初始化块

如果类有静态成员赋值或者静态初始化块，执行静态成员赋值和静态初始化块

将类的成员赋予初值（原始类型的成员的值为规定值，例如int型为0，float型为0.0f，boolean型为false；对象类型的初始值为null）

如果构造方法中存在this()调用（可以是其它带参数的this()调用）则执行之，执行完毕后进入第7步继续执行，如果没有this调用则进行下一步。（这个有可能存在递归调用其它的构造方法）

执行显式的super()调用（可以是其它带参数的super()调用）或者隐式的super()调用（缺省构造方法），此步骤又进入一个父类的构造过程并一直上推至Object对象的构造。

执行类申明中的成员赋值和初始化块。

执行构造方法中的其它语句。

 

最终的简化顺序版本是：

 

父类的静态成员赋值和静态块

子类的静态成员和静态块

父类的构造方法

父类的成员赋值和初始化块

父类的构造方法中的其它语句

子类的成员赋值和初始化块

子类的构造方法中的其它语句

 

 

------------------------------------分割线-------------------------------------------------

 

 

一、java代码执行顺序(理解形式)：

1、父类静态代码块->子类静态代码块（只执行一次）；

2、父类成员变量的初始化或普通代码块->父类构造函数；

3、子类成员变量的初始化或普通代码块->子类构造函数。

 

二、概念：               

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

eg: static

{       

 System.out.println("static block of demo!");

}

 

普通代码块是指在类中直接用大括号{}括起来的代码段。

eg:

{

  System.out.println("comman block of demo!");

}

 

package com.dk.java.controller;


class Parent {
	private Delegete delegete = new Delegete();//4 11

	static// 加载时执行，只会执行一次
	{
		System.out.println("static block of parent!");//1
	}

	public Parent(String name) {
		System.out.println("to construct parent!"); //6 13
	}

	{
		System.out.println("comman block of parent!");//5 12
	}
}

public class Child extends Parent {
	static {
		System.out.println("static block of child!");//2
	}

	static// 可以包含多个静态块，按照次序依次执行
	{
		System.out.println("second static block of child!");//3
	}

	// 普通代码块与变量的初始化等同的，按照次序依次执行
	{
		System.out.println("comman mode of child!"); //7 13
	}

	private Delegete delegete = new Delegete();//8 14

	{
		System.out.println("second comman mode of child!");//9 15
	}

	// 构造顺序，先执行静态块(父类、子类顺序执行)(只执行一次)
	// 执行父类成员变量的初始化或普通代码块，然后执行构造函数
	// 执行子类成员变量的初始化或普通代码块，然后执行构造函数
	public Child() {
		super("DLH");
		System.out.println("to construct child!");//10 16
	}

	public static void main(String[] args) {
		Child c = new Child();
		System.out.println("**********************************");
		Child c2 = new Child();
	}
}

class Delegete {
	static {
		System.out.println("static of Delegete!"); //4.1
	}

	public Delegete() {
		System.out.println("to construct delegete!"); //4.2 8.1 11.1 14.1
	}
}

  

 

输出结果：

static block of parent!
static block of child!
second static block of child!
static of Delegete!
to construct delegete!
comman block of parent!
to construct parent!
comman mode of child!
to construct delegete!
second comman mode of child!
to construct child!
**********************************
to construct delegete!
comman block of parent!
to construct parent!
comman mode of child!
to construct delegete!
second comman mode of child!
to construct child!

 

 对单个类，JVM加载阶段（编译阶段）:

1、给静态变量分配内存空间

2、用默认值初始化静态变量

3、按照静态变量和静态块的申明顺序执行初始化

4、如果创建对象；否则，直接结束

5、先给所有实例成员分配内存空间并用默认值初始化

6、按顺序执行实例块和变量

7、执行构造方法