package com.luke.java;
/**
*@descripton
*@author luke
*@time 2012-7-20:下午02:13:27
*@version
*/
public class ClassA
{
/**
* <p>Title: </p>
* <p>Description: </p>
*/
public ClassA(String msg)
{
super();
// TODO Auto-generated constructor stub
System.out.println(msg + " in ClassA");
}
}
package com.luke.java;
/**
*@descripton
*@author luke
*@time 2012-7-20:下午02:14:12
*@version
*/
public class ClassB
{
public ClassB(String msg)
{
super();
// TODO Auto-generated constructor stub
System.out.println(msg + " in ClassB");
}
}
package com.luke.java;
/**
*@descripton
*@author luke
*@time 2012-7-20:下午02:12:57
*@version
*/
public class Parent
{
private static ClassA classA = new ClassA("parent static classA");
static
{
System.out.println("parent static block");
}
private int i = 10;
{
System.out.println("parent common block");
}
private ClassB classB = new ClassB("parent common classB");
public Parent(int i)
{
this.i = i;
System.out.println("parent constructor");
}
public void callInnerClass()
{
InnerClass innerClass = new InnerClass();
}
protected static class InnerClass
{
private static ClassA classA = new ClassA("parent InnerClass static classA");
static
{
System.out.println("parent InnerClass static block");
}
private ClassB classB = new ClassB("parent InnerClass common classB");
{
System.out.println("parent InnerClass common block");
}
public InnerClass()
{
System.out.println("parent InnerClass constructor");
}
}
}
package com.luke.java;
/**
*@descripton
*@author luke
*@time 2012-7-20:下午02:21:19
*@version
*/
public class Child extends Parent
{
private static ClassB classB = new ClassB("child static classB");
static
{
System.out.println("child static block");
}
private ClassA classA = new ClassA("child common classA");
private int j = 20;
{
System.out.println("child common block");
}
public Child(int i, int j)
{
super(i);
// TODO Auto-generated constructor stub
this.j = j;
System.out.println("child constructor");
}
public void callInnerClass()
{
//Parent.InnerClass innerClass = new Parent.InnerClass();//如果Parent的InnerClass设置成private就不能引用
InnerClass innerClass = new InnerClass();
}
private static class InnerClass
{
private static ClassA classA = new ClassA("child InnerClass static classA");
static
{
System.out.println("child InnerClass static block");
}
private ClassB classB = new ClassB("child InnerClass common classB");
{
System.out.println("child InnerClass common block");
}
public InnerClass()
{
System.out.println("child InnerClass constructor");
}
}
}
package com.luke.java;
/**
*@descripton
*@author luke
*@time 2012-7-20:下午02:12:36
*@version
*/
public class LoadOrderTest
{
/**
*@description
*@param
*@return void
*@author luke
*@time 2012-7-20:下午02:12:36
*@version
*/
public static void main(String[] args)
{
// TODO Auto-generated method stub
/*
* 输出结果如下
*
parent static classA in ClassA
parent static block
parent common block
parent common classB in ClassB
parent constructor
parent InnerClass static classA in ClassA
parent InnerClass static block
parent InnerClass common classB in ClassB
parent InnerClass common block
parent InnerClass constructor
* */
Parent parent = new Parent(60);
parent.callInnerClass();
/*
* 输出结果如下
*
parent static classA in ClassA
parent static block
child static classA in ClassB
child static block
parent common block
parent common classB in ClassB
parent constructor
child common classA in ClassA
child common block
child constructor
child InnerClass static classA in ClassA
child InnerClass static block
child InnerClass common classB in ClassB
child InnerClass common block
child InnerClass constructor
* */
Child child = new Child(30, 40);
child.callInnerClass();
}
}
说明 :
1.静态变量与静态模块是最先初始化的,它是属于进程的静态常量区
2.Parent的构造器要先于它的子类,这一点是肯定的,但Parent的变量,初始化模块要先于它的子类,构造器可能涉及到类变量操作,所以既然先初始化了父类的构造器,那父类的成员变量也当然要先构造
3.静态变量与静态模块的初始化顺序是根据在类里面定义的顺序,同理变量化初始化模块的顺序也是根据类里面定义的顺序
4.内部静态类在用的时候才会初始化
先父类后子类;
先静态,再初始化,最后构造函数;
父类静态变量(静态初始化块)(按类定义顺序)> 子类静态变量(静态初始化块)(按类定义顺序)>父类普通变量(普通初始化块)(按类定义顺序)>父类构造方法>父类普通方法>子类普通变量(普通初始化块)(按类定义顺序)>子类构造方法>子类普通方法