Java类属性和对象属性的初始化顺序如下：
(1) 类属性（静态变量）定义时的初始化
(2) static块中的初始代码 
(3) 对象属性（非静态变量）定义时的初始化
(4) 构造方法（函数）中的初始化代码


下面举例说明：
<pre name="code" class="java">public class test {
	
	//类属性
	static String a = "string-a";
	static String b;
	
	//对象属性
	String c = "string-c";
	String d;
	
	//static块
	static{
		printStatic("before static");
		b = "string-b";
		printStatic("after static");
	}
	
	public static void printStatic(String title)
	{
		System.out.println("***********"+title+"*****************");
		System.out.println("a = \"" + a + "\"");
		System.out.println("b = \"" + b + "\"");	
	}
	
	//构造函数
	public test()
	{
		print("before constructor");
		d = "string -d";
		print("after constructor");
	}
	
	public void print(String title)
	{
		System.out.println("************"+ title + "****************");
		System.out.println("a = \"" + a + "\"");
		System.out.println("b = \"" + b + "\"");	
		System.out.println("c = \"" + c + "\"");
		System.out.println("d = \"" + d + "\"");	
		
	}

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

	}

}

上面程序的运行结果如下：
***********before static*****************
a = "string-a" 
b = "null"
***********after static*****************
a = "string-a"
b = "string-b"
************before constructor****************
a = "string-a"
b = "string-b"
c = "string-c"
d = "null"
************after constructor****************
a = "string-a"
b = "string-b"
c = "string-c"
d = "string -d"
由此可以看出类属性与对象属性的初始化顺序。

1）类属性（静态变量）定义时的初始化，如：static String ="string-a";
2)static块中的初始化代码，如
static{
string b="string -b";
}
3)对象属性（非静态变量）定义时的初始化，如：static c="string -c";
4)构造方法（函数）中的初始化代码，

代码演示：

public class usingAttribute

{

static String str1=“string1”;

static String str2;

String str3=“string3”;

String str4;

static{//static语句用于初始化static成员变量，是最先运行的语句块

printStatic(“before static”);

str2=“string2”;

printStatic(“after static”);

}

public static void printStatic(String title)

{

System.out.println("------"+title+"-----");

System.out.println(“str1=”"+str1+""");

System.out.println(“str2=”"+str2+""");
}
public usingAttribute()
{
	print("before constructor");
	str4="string4";
	print("after constructor");
}//定义了一个构造方法usingAttribute()，在这个方法中，使用了类中的各个属性。构造方法与类同名，且无返回值（包括void），它的主要目的是创建对象。
public void print(String title)
{
	System.out.println("-----"+title+"-----");
	System.out.println("str1=\""+str1+"\"");
	System.out.println("str2=\""+str2+"\"");
	System.out.println("str3=\""+str3+"\"");
	System.out.println("str4=\""+str4+"\"");
}
public static void main(String[] args){
	System.out.println();
	System.out.println("-----创建usingAttribute对象-----");
	System.out.println();
	new usingAttribute();//使用关键字new和构造方法usingAttribute()来创建一个匿名对象；
}

}

由输出结果可以看出，Java类属性和对象属性的初始化顺序如下：

（1）类属性（静态变量）定义时的初始化，如范例中的static String str1=“string1”;

（2）static块中的初始化代码，如范例中的static{}中的str2=“string-2”；

（3）对象属性（非静态变量）定义时的初始化，如范例中的String str3=“string3”;

（4）构造方法（函数）中的初始化代码，如范例构造方法中的str4=“string4”.

当然这里只是为了演示java类中的属性和对象属性的初始化顺序。在实际的应用中并不建议在类中定义属性时实施初始化，如例子中的字符串变量：“str1”,“str3”.

请注意，被static修饰的变量称为类变量（class variables）,它们被类的实例所共享。也就是说，某一个类的实例化改变了这个静态值，其他这个类的实例也会受到影响。而成员变量（member variable）则是没有被static修饰的变量，为实例所私有，也就是说，每个类的实例都有一份自己专属的成员变量，只有当前实例才可更改它们的值。

static是一个特殊的关键字，其在英文中直译就是“静态”的意思。它不仅用于修饰属性（变量）、成员，还可以用来修饰类中的方法。被static修饰的方法，同样表明它是属于这个类共有的，而不是属于该类的单个实例，通常把static修饰的方法也称为类方法。

Java 类中类属性 (static 变量) 和对象属性 (非 static 变量) 的初始化顺序可以用如下程序测试：
　　
　　/**
　　* @(#) Test.java
　　* @author fancy
　　*/
　　
　　public class Test {
　　
　　static String a = "string-a";
　　static String b;
　　
　　String c = "stirng-c";
　　String d;
　　
　　static {
　　printStatic("before static");
　　b = "string-b";
　　printStatic("after static");
　　}
　　
　　public static void printStatic(String title) {
　　System.out.println("---------" + title + "---------");
　　System.out.println("a = /"" + a + "/"");
　　System.out.println("b = /"" + b + "/"");
　　}
　　
　　public Test() {
　　print("before constrUCtor");
　　d = "string-d";
　　print("after constructor");
　　}
　　
　　public void print(String title) {
　　System.out.println("---------" + title + "---------");
　　System.out.println("a = /"" + a + "/"");
　　System.out.println("b = /"" + b + "/"");
　　System.out.println("c = /"" + c + "/"");
　　System.out.println("d = /"" + d + "/"");
　　}
　　
　　public static void main(String[] args) {
　　new Test();
　　}
　　
　　}
　　
　　首先，我把 main() 方法注释掉，运行结果如下：
　　
　　---------before static---------
　　a = "string-a"
　　b = "null"
　　---------after static---------
　　a = "string-a"
　　b = "string-b"
　　java.lang.NoSuchMethodError: main
　　Exception in thread "main"
　　Process completed.
　　
　　然后，取消对 main() 方法的注释，运行结果如下：
　　
　　---------before static---------
　　a = "string-a"
　　b = "null"
　　---------after static---------
　　a = "string-a"
　　b = "string-b"
　　---------before constructor---------
　　a = "string-a"
　　b = "string-b"
　　c = "stirng-c"
　　d = "null"
　　---------after constructor---------
　　a = "string-a"
　　b = "string-b"
　　c = "stirng-c"
　　d = "string-d"
　　
　　由此可以看出 Java 类属性和对象属性的初始化顺序如下：
　　
　　① 类属性 (静态变量) 定义时的初始化，如上例的 static String a = "string-a";
　　② static 块中的初始化代码，如上例 static {} 中的 b = "string-b";
　　③ 对象属性 (非静态变量) 定义时的初始化，如上例的 String c = "stirng-c";
　　④ 构造方法 (函数) 中的初始化代码，如上例构造方法中的 d = "string-d";
　　
　　在此过程中 ② 和 ③ 的顺序无所确定，因为在静态块中无法打印出非静态变量。
同样是因为这个原因，知道他们的顺序对我们写程序也毫无帮助。再因为类成员 (静态成员) 是在第一次使用到类的时候就进行了相应的初始化，而对象成员 (非静态成员) 则需要生成类实例 (即对象) 时才能初始化，所以我把 ③ 排在了 ② 的后面。再申明一次，它们究竟谁先谁后，从代码上是不能确定的，恐怕需要去研究一下 JVM (Java 虚拟机) 的执行过程才行。
　　
　　
　　以下是一些回帖的讨论：
　　我对狂人教程"对象成员 (非静态成员) 则需要生成类实例 (即对象) 时才能初始化"有些看法！例如你在例程中定义的两个对象成员变量String c = "stirng-c";
　　String d;我认为当程序执行这个Test类的时候,成员变量(不包括构造函数)和类成员变量一样，都要装载到内存。这样对象成员变量就可以被构造函数所调用。但是究竟静态变量和非静态变量哪个先执行可以看在代码中的先后顺序，但是这对于编写代码来说并没有多大的用处！
　　
　　static
　　{
　　printStatic("before static");
　　b = "string-b";
　　printStatic("after static");
　　}在??第一次使用而蒌入??行，且只?行一次。。。。。
　　--caterpillar 
（http://www.hackhome.com/）（http://www.hackhome.com/InfoView/Article_117743_2.html）