1、很重要！！！    
例子：
package Servlet.day0811.am;
public class StaticTest {
	static StaticTest st=new StaticTest();
	static{
		System.out.println("静态代码块");
	}
	public StaticTest(){
		System.out.println("构造器");
		System.out.println(st);
		m1();
	}	
	public static void m1(){
		System.out.println("m1静态方法");
		System.out.println(st);
	}
	{
		System.out.println("普通代码块");
	}
	public static void main(String[] args) {
		System.out.println("main开始");
		StaticTest.m1();
		System.out.println("main结束");
	}
}
-------------------------------------结果如下-------------------------------------
普通代码块    （先加载普通代码块）
构造器        （再加载构造器）
null          （输出构造器中的st，此时并未加载静态属性，所以输出null）
m1静态方法    （构造器中的m1方法，输出m1静态方法）
null          （m1方法中的st，此时st仍然未被加载）
静态代码块    （加载静态代码块）
main开始      （main方法开始，st在这时候被加载（分配内存））
m1静态方法    （调用静态方法m1）
Servlet.day0811.am.StaticTest@d1f24bb  （st已经被加载过了，所以为对象对应的地址）
main结束      （main方法结束）

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2、
    1、虚拟机在首次加载Java类时，会对静态初始化块、静态成员变量、静态方法进行一次初始化
    2、只有在调用new方法时才会创建类的实例
    3、类实例创建过程：按照父子继承关系进行初始化，首先执行父类的初始化块部分，然后是父类
 的构造方法；再执行本类继承的子类的初始化块，最后是子类的构造方法
    4、类实例销毁时候，首先销毁子类部分，再销毁父类部分
public class Dervied extends Base{
	private String name="dervied";
	public Dervied(){
		System.out.println(new Base().i);
		tellName();
		printName();
	}
	static{
		System.out.println("子类静态代码块");
	}
	public void tellName(){
		System.out.println("Dervied tell name : "+name);
	} 
	public void printName(){
		System.out.println("Dervied print name : "+name);
	}
	public static void main(String[] args) {
		new Dervied();
	}
}
class Base{
	public int i=99;
	private String name="111";
	static{
		System.out.println("父类静态代码块");
	}
	{
		System.out.println("父类非静态代码块");
	}
	public Base(){
		tellName();
		printName();
	}
	public void tellName(){
		System.out.println("Base tell name : "+name);
	} 
	public void printName(){
		System.out.println("Base print name : "+name);
	}
}
-------------------------------------结果如下-------------------------------------

父类静态代码块

子类静态代码块

父类非静态代码块

Dervied tell name : null

Dervied print name : null

父类非静态代码块

Base tell name : 111

Base print name : 111

99

Dervied tell name : dervied

Dervied print name : dervied

++++++++++++++++++++++++++做如下修改++++++++++++++++++++++++++++

将main方法里面new Dervied( ) 改为：System.out.println("hello");

结果为：        

    父类静态代码块

    子类静态代码块

    hello


============================================================

3、

class Farther{

public static int a=2;

public int b=3;

{

System.out.println("非静态代码块：b="+b);

}

static{

a=4;

System.out.println("静态代码块：a="+a);

}

public Farther(){

System.out.println("父类构造器");

this.s();

}

public void s(){

System.out.println("父类方法");

}

}

public class Son extends Farther{

public Son(){

System.out.println("子类构造器");

}

public static void main(String[] args) {

Farther f=new Son();

f.s();

}

public void s(){

super.s();

System.out.println("子类方法");

}

}

-------------------------------------结果如下-------------------------------------

静态代码块：a=4

非静态代码块：b=3

父类构造器

父类方法

子类方法

子类构造器

父类方法

子类方法

==========================================================

4、

public class InitializeDemo {

private static int k=1;

private static InitializeDemo t1=new InitializeDemo("t1");

private static InitializeDemo t2=new InitializeDemo("t2");

private static int i=print("1");

private static int n=99;

static{

print("静态代码块");

}

private int j=print("j");

{

print("非静态代码块");

}

public InitializeDemo(String str){

System.out.println(k++ + " : "+ str +"  i="+i+"  n="+n);

++i;

++n;

}

public static int print(String str){

System.out.println(k++ + " : "+ str +"  i="+i+"  n="+n) ;

++n;

return ++i;

}

public static void main(String[] args) {

new InitializeDemo("init");

}

}

-------------------------------------结果如下-------------------------------------

1 : j  i=0  n=0

2 : 非静态代码块  i=1  n=1

3 : t1  i=2  n=2

4 : j  i=3  n=3

5 : 非静态代码块  i=4  n=4

6 : t2  i=5  n=5

7 : 1  i=6  n=6

8 : 静态代码块  i=7  n=99

9 : j  i=8  n=100

10 : 非静态代码块  i=9  n=101

11 : init  i=10  n=102