类化顺序为:

(静态变量、静态化块)—— (变量、化块)—— 构造

测试代码:

public InitialOrderTest {
// 静态变量
public String Field = "静态变量";


// 变量
public String field = "变量";


// 静态化块
{
.out.prln(Field);
.out.prln("静态化块");
}


// 化块
{
.out.prln(field);
.out.prln("化块");
}


// 构造器
public InitialOrderTest {
.out.prln("构造器");
}


public void (String args) {
InitialOrderTest;
}
}
运行以上代码我们会得到如下输出结果:
1. 静态变量
2. 静态化块
3. 变量
4. 化块
5. 构造器

B类——extends——A类

创建子类B对象顺序:

第步:分配空间(A ,B空间次性分配)

第 2步:执行(A ,B ) 静态代码块、静态变量 // 2者根据出现先后顺序执行

第 3步:化A例子变量A代码块 // 2者根据出现先后顺序执行

第 4步:A构造

第 5步:化B例子变量和代码块

第 6步:B构造

Parent {


// 静态变量
public String p_StaticField = "父类--静态变量";


// 变量
public String p_Field = "父类--变量";


// 静态化块
{
.out.prln(p_StaticField);
.out.prln("父类--静态化块");
}


// 化块
{
.out.prln(p_Field);
.out.prln("父类--化块");
}



// 构造器
public Parent {
.out.prln("父类--构造器");
}
}


public SubClass extends Parent {


// 静态变量
public String s_StaticField = "子类--静态变量";


// 变量
public String s_Field = "子类--变量";


// 静态化块
{
.out.prln(s_StaticField);
.out.prln("子类--静态化块");
}


// 化块
{
.out.prln(s_Field);
.out.prln("子类--化块");
}


// 构造器
public SubClass {
.out.prln("子类--构造器");
}


// 入口
public void (String args) {
SubClass;
}
}


运行下上面代码:
1. 父类--静态变量
2. 父类--静态化块
3. 子类--静态变量
4. 子类--静态化块
5. 父类--变量
6. 父类--化块
7. 父类--构造器
8. 子类--变量
9. 子类--化块
10.子类--构造器


注意并不是父类完全化完毕后才进行子类化实际上子类静态变量和静态化块化是在父类变量、化块和构造器化的前就完成了
那么对于静态变量和静态化块的间、变量和化块的间先后顺序又是怎样呢？这取决于它们在类中出现先后顺序我们以静态变量和静态化块为例来进行介绍说明


测试:

public TestOrder {
// 静态变量
public TestA a = TestA;
// 静态化块
{
.out.prln("静态化块");
}
// 静态变量
public TestB b = TestB;
public void (String args) {
TestOrder;
}
}
TestA {
public TestA {
.out.prln("Test--A");
}
}
TestB {
public TestB {
.out.prln("Test--B");
}
}


运行结果:
1. Test--A
2. 静态化块
3. Test--B

静态变量和静态化块是依照他们在类中定义顺序进行化同样变量和化块也遵循这个规律