java中类/对象的初始化顺序以及静态代码块的使用

一、对象的初始化顺序:

(1)加载父类（以下序号相同，表明初始化是按代码从上到下的顺序来的）

　　1.为父类的静态属性分配空间并赋于初值

　　1.执行父类静态初始化块;

(2)加载子类

　　2.为子类的静态属性分配空间并赋于初值

　　2.执行子类的静态的内容;

(3)加载父类构造器

　　3.初始化父类的非静态属性并赋于初值

　　3.执行父类的非静态代码块;

　　4.执行父类的构造方法;

(4)加载子类构造器

　　5.初始化子类的非静态属性并赋于初值

　　5.执行子类的非静态代码块;

　　6.执行子类的构造方法.

总之一句话，静态代码块内容先执行（父先后子），接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

二、静态变量和静态代码块的初始化顺序：

　　谁在前面先初始化谁（这个也比较容易理解，初始化的时候，不可能跳着去初始化吧，比如说静态代码块在静态变量的前面，不可能先跳过静态代码块的初始化先去执行静态变量的初始化吧。）

注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用
父类带参数的构造方法，否则编译不能通过,并且此语句必须置于子类构造方法的首句。

三、类装载步骤
   在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的，各个步骤的主要工作如下：
装载：查找和导入类或接口的二进制数据；
链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；
校验：检查导入类或接口的二进制数据的正确性；
准备：给类的静态变量分配并初始化存储空间；
解析：将符号引用转成直接引用；
初始化：激活类的静态变量的初始化Java代码和静态Java代码块。
初始化类中属性是静态代码块的常用用途，但只能使用一次。

对象的初始化顺序测试代码：

class Parent {
static String name = "hello";
{
System.out.println("parent block");
}
static {
System.out.println("parent static block");
}

public Parent() {
System.out.println("parent constructor");
}
}

class Child extends Parent {
static String childName = "hello";
{
System.out.println("child block");
}
static {
System.out.println("child static block");
}

public Child() {
System.out.println("child constructor");
}
}

public class StaticIniBlockOrderTest {

public static void main(String[] args) {
new Child();// 语句(*)
}
}

运行结果：
　parent static block
　　child static block
　　parent block
　　parent constructor
　　child block
　　child constructor
静态变量和静态代码块的初始化顺序测试代码：

TestOrder 


public class TestOrder {
//静态变量
public static TestA a = new TestA();

//静态初始化块
static {
System.out.println("静态初始化块");
}

//静态变量
public static TestB b = new TestB();

public static void main(String[] args) {
new TestOrder();
}
}

class TestA {
public TestA() {
System.out.println("Test--A");
}
}

class TestB {
public TestB() {
System.out.println("Test--B");
}
}

运行结果：

　　Test--A
　　静态初始化块
　　Test--B
再加一个经典的测试代码

  
class insect{ 
    int i=9; 
    int j; 
    static { 
        prt("static block first,because it's begin of the static variable"); 
    } 
    insect(){ 
        System.out.println("insect initialized"); 
  
       prt("i= "+i+" j="+j); 
  
       j=39; 
  
    } 
  
    static int x1=prt("static insect x1 initialized"); 
  
    static int prt(String s){ 
  
       System.out.println(s); 
  
       return 47; 
  
    } 
  
} 
  
public class Wps extends insect{ 
      
    Wps(){ 
        System.out.println("wps initialized"); 
  
       prt("k="+k); 
  
       prt("j="+j); 
  
    } 
    int k=prt("the member k in wps be initialized"); 
  
    static int x2=prt("static wps x2 initialized"); 
  
    static int prt(String s){ 
  
       System.out.println(s); 
  
       return 63; 
  
    }   
  
public static void main(String[] args){ 
       //程序的入口，开始加载父类，然后开始加载子类，然后是父类构造方法，然后是子类构造方法
       insect.prt("initialized constructor"); 
       System.out.println("=========================");
      Wps w=new Wps(); 
  
    } 
  
}

运行结果：
static block first,because it's begin of the static variable
static insect x1 initialized
static wps x2 initialized
initialized constructor
=============================================
insect initialized
i= 9 j=0
the member k in wps be initialized
wps initialized
k=63
j=39

测试代码：

public class Limin {
	Limin1 lm = new Limin1();
	static {
		System.out.println("wawo");
	 }
	{
		System.out.println("haha");
	}
	public static void main(String[] args) {
		//Limin l =new Limin();  此行注释掉，代表并没有调用默认不带参数的构造方法，当运行的时候只是加载了父类和子类，并没有加载父类和子类的构造器
		
	}

}

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

}

运行结果：
wawo
把注释解除的运行结果如下：
wawo
liminsss 按照从上到下的顺序，先初始化非静态属性，然后是非静态块，然后是构造方法
haha