类初始化问题（转载）

gao_20022002

浏览: 164849 次
性别:
来自: 杭州

最近访客更多访客>>

afu

zouyongqkdly

zys6024

n752543926

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

转载

Blog

对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序以此是（静态变量、静态初始化块）>（变量、初始化块）>构造器。
我们也可以通过下面的测试代码来验证这一点：
Java代码

public class InitialOrderTest {   
  
    // 静态变量   
    public static String staticField = "静态变量";   
    // 变量   
    public String field = "变量";   
  
    // 静态初始化块   
    static {   
        System.out.println(staticField);   
        System.out.println("静态初始化块");   
    }   
  
    // 初始化块   
    {   
        System.out.println(field);   
        System.out.println("初始化块");   
    }   
  
    // 构造器   
    public InitialOrderTest() {   
        System.out.println("构造器");   
    }   
  
    public static void main(String[] args) {   
        new InitialOrderTest();   
    }   
}

运行以上代码，我们会得到如下的输出结果：

静态变量
静态初始化块
变量
初始化块
构造器

这与上文中说的完全符合。那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果：
Java代码

class Parent {
	// 静态变量
	public static String p_StaticField = "父类--静态变量";
	// 变量
	public String p_Field = "父类--变量";

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

	// 初始化块
	{
		System.out.println(p_Field);
		System.out.println("父类--初始化块");
	}

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

public class SubClass extends Parent {
	// 静态变量
	public static String s_StaticField = "子类--静态变量";
	// 变量
	public String s_Field = "子类--变量";
	// 静态初始化块
	static {
		System.out.println(s_StaticField);
		System.out.println("子类--静态初始化块");
	}
	// 初始化块
	{
		System.out.println(s_Field);
		System.out.println("子类--初始化块");
	}

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

	// 程序入口
	public static void main(String[] args) {
		new SubClass();
	}
}

运行一下上面的代码，结果马上呈现在我们的眼前：

父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器

现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。

那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。

同样，我们还是写一个类来进行测试：
Java代码

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

大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。

了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了。

其实还可以增加内部类的相关初始化问题。

分享到：

inverse与cascade（转载） | java中内存分配策略及堆和栈的比较

2008-06-26 19:01
浏览 964
评论(4)
查看更多

4 楼 mercyblitz 2008-06-27

不错，看看这个吧！
关于类型的生命周期，相信对理解类初始化会有帮助的！
http://mercyblitz.blog.ccidnet.com/blog-htm-do-showone-uid-45914-type-blog-itemid-167315.html

3 楼 gao_20022002 2008-06-26

public class TestA {

	class A {
		String string1 = "内部类--实例数据";
		{
			System.out.println(string1);
		}
		
		public A(){
			System.out.println("内部类--构造器");
		}

	}
	
	public TestA(){
		System.out.println("主类--构造器");
	}

	static String string2 = "主类--静态数据";
	String string3 = "主类--实例数据";
	static {
		System.out.println(string2);
	}
	{
		System.out.println(string3);
	}

	public static void main(String[] args) {
		new TestA().new  A();
	}
}

运行上面的代码，会得到如下的结果：
主类--静态数据
主类--实例数据
主类--构造器
内部类--实例数据
内部类--构造器

同样，还是先初始化主类，然后初始化内部类。

可以得出这样的结论：
平常的基础类（即没有继承关系，内部类），初始化顺序：（静态数据|静态块）-->（实例数据|实例块）-->构造器。

继承的类，初始化顺序：继承类首先初始化，如果再次继承以此类推，最顶层类执行（静态数据|静态块），次顶层类执行（静态数据|静态块），以此类推，直至最底层基类，然后最顶层类执行（实例数据|实例块）-->构造器，次顶层类执行（实例数据|实例块）-->构造器，以此类推，直至最底层基类。

public class UpParent {
	
	// 静态变量
	public static String p_StaticField = "父父类--静态变量";
	// 变量
	public String p_Field = "父父类--变量";

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

	// 初始化块
	{
		System.out.println(p_Field);
		System.out.println("父父类--初始化块");
	}

	// 构造器
	public UpParent() {
		System.out.println("父父类--构造器");
	}

}

public class Parent extends UpParent{
	// 静态变量
	public static String p_StaticField = "父类--静态变量";
	// 变量
	public String p_Field = "父类--变量";

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

	// 初始化块
	{
		System.out.println(p_Field);
		System.out.println("父类--初始化块");
	}

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

}

public class SubClass extends Parent {
	// 静态变量
	public static String s_StaticField = "子类--静态变量";
	// 变量
	public String s_Field = "子类--变量";
	// 静态初始化块
	static {
		System.out.println(s_StaticField);
		System.out.println("子类--静态初始化块");
	}
	// 初始化块
	{
		System.out.println(s_Field);
		System.out.println("子类--初始化块");
	}

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

	// 程序入口
	public static void main(String[] args) {
		new SubClass();
	}

}

2 楼 gao_20022002 2008-06-26

public class TestA {

	static class A {
		static String string1 = "内部类--静态数据";
		String string2 = "内部类--实例数据";
		static {
			System.out.println(string1);
		}
		{
			System.out.println(string2);
		}

	}

	static String string3 = "主类--静态数据";
	String string4 = "主类--实例数据";
	static {
		System.out.println(string3);
	}
	{
		System.out.println(string4);
	}

	public static void main(String[] args) {
		new A();
		System.out.println("---------");
		new TestA();
	}
}

运行上面的代码，会得到如下的结果：
主类--静态数据
内部类--静态数据
内部类--实例数据
---------
主类--实例数据
说明：
静态内部类调用也会首先初始化主类的静态数据，然后初始化静态内部类数据，实例数据。当然，静态数据与静态块遵照先后顺序。

1 楼 minstrel 2008-06-26

精彩!为什么代码都贴两遍?

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论