java初始化顺序

一、初始化顺序

在类的内部，变量的定义顺序先后决定了初始化的顺序。即使变量定义在不同的方法之间，它们也会在任何方法（包括构造函数）在调用之前初始化。

1.简单的初始化顺序：

class Sample {
Sample() {
System.out.println("Sample默认构造函数被调用");
}
Sample(String s) {
System.out.println(s);
}
}
public class JavaInit {
Sample sam1 = new Sample("sam1成员初始化");
JavaInit() {
System.out.println("JavaInit默认构造函数被调用");
}
Sample sam2 = new Sample("sam2成员初始化");
void print() {
System.out.println("print()");
}
public static void main(String[] args) {
JavaInit ji = new JavaInit();
ji.print();
}
}

输出：

sam1成员初始化

sam2成员初始化

JavaInit默认构造函数被调用

print()

2、静态数据初始化：

public class JavaStaticInit {
static Sample sam = new Sample("静态成员sam初始化");
Sample sam1 = new Sample("sam1成员初始化");
JavaStaticInit() {
System.out.println("JavaStaticInit默认构造函数被调用");
}
public static void main(String str[]) {
JavaStaticInit a = new JavaStaticInit();
JavaStaticInit a1 = new JavaStaticInit();
}

输出：

静态成员sam初始化

sam1成员初始化

JavaStaticInit默认构造函数被调用

sam1成员初始化

JavaStaticInit默认构造函数被调用

由输出结果可以看到：只有在第一个JavaStaticInit对象被创建（或第一次的访问静态数据）的时候，它们才会被初始化，此后，静态对象不会被再次初始化。

3、静态块的初始化：

public class JavaStaticInit {
static {
System.out.println("static 块 1  执行");
}
static Sample sam = new Sample("静态成员sam初始化");
Sample sam1 = new Sample("sam1成员初始化");
JavaStaticInit() {
System.out.println("JavaStaticInit默认构造函数被调用");
}
static {
System.out.println("static块执行");
Sample sam2 = new Sample("静态块内初始化sam成员变量");
}
public static void main(String str[]) {
JavaStaticInit a = new JavaStaticInit();
JavaStaticInit a1 = new JavaStaticInit();

}

输出：

static 块 1 执行

静态成员sam初始化

static块执行

静态块内初始化sam成员变量

sam1成员初始化

JavaStaticInit默认构造函数被调用

sam1成员初始化

JavaStaticInit默认构造函数被调用

由此而知，对于静态成员（static块可以看成普通的一个静态成员，其并不一定在类初始化时首先执行）之间或者普通成员之间，其初始化顺序只与其在类定义中的顺序有关，和其他因素无关。

4.非静态实例初始化：

class Mug {
Mug(int mark) {
System.out.println("Mug(" + mark + ")");
}
}

public class Mugs {
Mug mug1;
Mug mug2;
Mug mug3;
Mug mug4;
{
mug1 = new Mug(1);
mug2 = new Mug(2);
System.out.println("mug1---------------------mug2");
}
Mugs() {
System.out.println("Mugs()");
}
Mugs(int mark) {
System.out.println("Mugs(" + mark + ")");
}
{
mug3 = new Mug(3);
mug4 = new Mug(4);
System.out.println("mug3---------------------mug4");
}
public static void main(String[] args) {
new Mugs();
new Mugs();
}
}

输出：

Mug(1)

Mug(2)

mug1———————mug2

Mug(3)

Mug(4)

mug3———————mug4

Mugs()

Mug(1)

Mug(2)

mug1———————mug2

Mug(3)

Mug(4)

mug3———————mug4

Mugs()

二、继承下的初始化

class A {
public static int a = 0;
public int b = 0;
Sample sam1 = new Sample("■父类 -普通变量-位置是构造函数前");
static {
System.out.println("■父类 - 静态初始块 - 位置是构造函数前");
}
{
System.out.println("■父类 - 普通初始块 - 位置是构造函数前");
}
public A() {
System.out.println("■父类 - 构造函数");
}
static {
System.out.println("■父类 - 静态初始块 - 位置是构造函数后");
}
{
System.out.println("■父类 - 普通初始块 - 位置是构造函数后");
}
Sample sam2 = new Sample("■父类 -普通变量-位置是构造函数后");

}

class B extends A {

Sample sam1 = new Sample(“◆子类 -普通变量-位置是构造函数后”);

static {

System.out.println(“◆子类 - 静态初始块 - 位置是构造函数前”);

}

{

System.out.println(“◆子类 - 普通初始块 - 位置是构造函数前”);

}

public B() {

System.out.println(“◆子类 - 构造函数”);

}

static {

System.out.println(“◆子类 - 静态初始块 - 位置是构造函数后”);

}

{

System.out.println(“◆子类 - 普通初始块 - 位置是构造函数后”);

}

Sample sam2 = new Sample(“◆子类 -普通变量-位置是构造函数后”);

}

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

}

输出：

■父类 - 静态初始块 - 位置是构造函数前

■父类 - 静态初始块 - 位置是构造函数后

◆子类 - 静态初始块 - 位置是构造函数前

◆子类 - 静态初始块 - 位置是构造函数后

■父类 -普通变量-位置是构造函数前

■父类 - 普通初始块 - 位置是构造函数前

■父类 - 普通初始块 - 位置是构造函数后

■父类 -普通变量-位置是构造函数后

■父类 - 构造函数

◆子类 -普通变量-位置是构造函数后

◆子类 - 普通初始块 - 位置是构造函数前

◆子类 - 普通初始块 - 位置是构造函数后

◆子类 -普通变量-位置是构造函数后

◆子类 - 构造函数

由此可知，

1、按照顺序执行父类静态变量、静态块

2、按照顺序执行子类静态变量、静态块

3、按照顺序执行父类的普通变量、普通块、执行父类的构造函数

4、按照顺序执行子类的普通变量、普通块、执行子类的构造函数

三、总结：

1、 继承体系的所有静态成员初始化（先父类，后子类）

2、 父类初始化（普通成员的初始化–>构造函数的调用）

3 、子类初始化（普通成员–>构造函数）


##一、

小知识点总结：

static{}(静态代码块)与{}(非静态代码块)的异同点

相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，

　　　　一般在代码块中对一些static变量进行赋值。

不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。

　　　　静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new

　　　　一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行