面试之：请写一个单例模式的程序

饥汉模式：

 * 优点：当类被加载的时候，已经创建好了一个静态的对象，因此，是线程安全的； 
 * 缺点：这个对象还没有被使用就被创建出来了。

public class HungrySingleton {
	// 私有化静态成员变量，已初始化
	private static HungrySingleton test = new HungrySingleton();

	// 私有化构造方法
	private HungrySingleton() {
	}

	// 提供一个公共的接口供外界获得单例对象
    // 不需要同步（类加载时已经初始化，不存在多线程的问题）
    // 始终只有一个对象
	public static HungrySingleton getInstance() {
		return test;
	}
}

懒汉模式：

 *  优点：按需加载对象，只有对象被使用的时候才会被创建
 *  缺点：这种写法不是线程安全的，例如当第一个线程执行判断语句if(test = null)时，
 *  第二个线程执行判断语句if(test = null),接着第一个线程执行语句test = new Test(), 
 *  第二个线程也执行语句test = new Test(),在这种多线程环境下，可能会创建出来两个对象。

public class LazySingleton {
	// 私有化静态成员变量，防止外界修改，没有实例化
	private static LazySingleton test = null;

	// 私有化构造方法，防止外界调用，保证对象是单例对象
	private LazySingleton() {
	}

	// 提供一个公共的接口供外界获得单例对象
	// 当多个线程都在调用此方法时，必须保证只有一个单例对象生成，
	// 这里采用对同步代码块加上
	// 因为成员变量是静态的，该方法也必须是静态方法
	public static LazySingleton getInstance() {
		if (test == null) {
			// 静态方法，使用当前类本身充当进程锁
			synchronized (LazySingleton.class) {
				test = new LazySingleton();
			}
		}
		return test;
	}
}

为什么单例模式创建的实例要设置为静态的？

/**
 * 单例模式实现过程如下： 
 * 首先，将该类的构造函数私有化（目的是禁止其他程序创建该类的对象）；
 * 其次，在本类中自定义一个对象（既然禁止其他程序创建该类的对象，就要自己创建一个供程序使用，否则类就没法用，更不是单例）；
 * 最后，提供一个可访问类自定义对象的类成员方法（对外提供该对象的访问方式）。
 * 直白的讲就是，你不能用该类在其他地方创建对象，而是通过该类自身提供的方法访问类中的那个自定义对象。
 * 那么问题的关键来了，程序调用类中方法只有两种方式:
 * 			①创建类的一个对象，用该对象去调用类中方法；
 * 			②使用类名直接调用类中方法，格式“类名.方法名()”；
 * 上面说了，构造函数私有化后第一种情况就不能用，只能使用第二种方法。
 * 而使用类名直接调用类中方法，类中方法必须是静态的，而静态方法不能访问非静态成员变量，因此类自定义的实例变量也必须是静态的。
 * 这就是单例模式唯一实例必须设置为静态的原因。
 */