JAVA学习.静态块（静态代码段）分析

/**
 * 
 */
package staticblock;
//静态块的分析
/**
 * @author fshxxxyydys
 *
 */
public class StaticBlock {
	private int a = 0;
	  //实例变量的简单初始化
		
	private static int  cnt = 0;
	   
	  //静态变量的简单初始化

	static{ 
		if(cnt != 0)
			cnt = 0;
		System.out.println("StaticBlock00 is invoked!");
		
	}
	  //静态块：当类被加载之后静态变量就开辟了，静态块就
	  //会自动运行一次，而此时对象还未存在，所以静态块的
	  //运行将早与静态方法的运行。
	  //静态块没有名称，也叫匿名块，因为是自动运行的所以
	  //不需要名称，也不能被显示调用运行。
	  //静态块不能访问实例方法和属性。可以定义许多静态块。
	  //多个静态块执行的顺序医依靠其在代码中的顺序，但是
	  //必须定义在静态变量的定义之后方能访问到静态变量。
	public StaticBlock() {
		  this.a = 0; 
		  System.out.println(" Constructor is invoked!");
	  //实例变量可以在构造函数中进行初始化
		  
		  // b = 99; 
	  //静态虽然也可以在构造函数中进行初始化但是由于没有
	  //生成对象的时候静态变量已经存在而且可以使用，而且
	  //有的静态变量的值可能要经过许多计算才可以获得，使
	  //用该方法明显不合适，因此就产生了静态块的概念。
		  
		  
	  //顺便提示一下：静态方法也是在对象没有生成的时候就
	  //已经存在，所以静态方法是不可以调用实例变量和实例
	  //的，道理很简单:没有存在的东西该如何调用呢。
	}
	static{ 
		
		cnt++;
		System.out.println("StaticBlock01 is invoked!");
		
	}
	static{ 
		
		cnt++;
		System.out.println("StaticBlock02 is invoked!");
		
	}
	
}

/**
 * 
 */
package staticblock;

/**
 * @author fshxxxyydys
 *
 */
public class Tester {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		StaticBlock sb0 = new StaticBlock();
		StaticBlock sb1 = new StaticBlock();
		StaticBlock sb2 = new StaticBlock();
		StaticBlock sb3 = new StaticBlock();
		//无论创建多少对象，静态块只会运行一次
		//而且只运行一次。
		
	}

}

==============================================================
Result：
StaticBlock00 is invoked!
StaticBlock01 is invoked!
StaticBlock02 is invoked!
 Constructor is invoked!
 Constructor is invoked!
==============================================================

有继承时：

package ljy.oraclejdbc.dao;

class Base {
	static int a = 1;

	public Base() {
		System.out.println("父类Base 构造函数");
	}

	static {
		System.out.println("父类Base 的静态代码段");
	}

	static void method() {
		System.out.println("父类Base 的静态方法");
	}
	// 强调：类在加载的时候会执行该类的静态代码段
	// 同时也会加载静态属性和方法，使用在对象没有
	// 被创造之前这些属性和方法就可以被调用。

}

class Sub extends Base {

	public Sub() {
		System.out.println(" 子类Sub的构造函数");
	}

	static int b = 2;
	static {
		System.out.println(" 子类Sub 的静态代码段");
	}
}

public class Traversc {
	public static void main(String[] args) {
		System.out.println("=========华丽的分割线=========");

		Sub.method();
		System.out.println("a=" + Sub.b);
		// 此时并没有创建类的实例对象,因为堆中的静态区域足以完成操作。

		System.out.println("=========华丽的分割线=========");

		System.out.println("a=" + Sub.b);
		Sub.method();
		// 可以看出静态代码段只运行一次（上面已经运行过了）

		System.out.println("=========华丽的分割线=========");
		Sub s = new Sub();
		System.out.println("a=" + Sub.a);
		Sub.method();
		// 只有对象创建的时候才会调用构造方法
		// 而且优先构造父类再依次构造子类。
	}
}

=====================================
Result：
=========华丽的分割线=========
父类Base 的静态代码段
父类Base 的静态方法
 子类Sub 的静态代码段
a=2
=========华丽的分割线=========
a=2
父类Base 的静态方法
=========华丽的分割线=========
父类Base 构造函数
 子类Sub的构造函数
a=1
父类Base 的静态方法
=====================================
原创出处：http://blog.csdn.net/u012830807