eff实现单例的3种方式

package eff;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 
 /**
  * 
  * @author lw
  * 
  */
 public class SingleSimpleTest {
     public static void main(String[] args) {
         try {
             testSingle();
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 
     private static void testSingle() throws ClassNotFoundException,
             SecurityException, NoSuchMethodException, IllegalArgumentException,
             InstantiationException, IllegalAccessException,
             InvocationTargetException {
         Single1 s1 = Single1.newInstance();
         Constructor c = Class.forName("eff.Single1").getDeclaredConstructor(
                 null);
         c.setAccessible(true);
         Single1 _s1 = (Single1) c.newInstance(null);
         System.out.println("懒汉Single pattern 测试结果 S1=_S1?: "
                 + (s1 == _s1 ? "SUCCESS" : "FAIL"));
 
         Single2 s2 = Single2.newInstance();
         Constructor c2 = Class.forName("eff.Single2").getDeclaredConstructor(
                 null);
         c2.setAccessible(true);
         Single2 _s2 = (Single2) c2.newInstance(null);
         System.out.println("饿汉Single pattern 测试结果 S2=_S2?: "
                 + (s2 == _s2 ? "SUCCESS" : "FAIL"));
 
         Single3 s3 = Single3.newInstance();
         Constructor c3 = Class.forName("eff.Single3").getDeclaredConstructors()[0];
         c3.setAccessible(true);
         System.out.println(c3.newInstance(null) == c3);
         c3.setAccessible(true);
         Single3 _s3 = (Single3) c3.newInstance(null);
         System.out.println("枚举Single pattern 测试结果 S3=_S3?: "
                 + (c3.newInstance(null) == c3 ? "SUCCESS" : "FAIL"));
     }
 }
 
 /**
  * 懒汉Single pattern
  * 
  * @author lw
  * 
  */
 class Single1 {
     private static final Single1 INSTANCE = new Single1();
 
     private Single1() {
     };
 
     public static Single1 newInstance() {
         return INSTANCE;
     }
 }
 
 /**
  * 饿汉 Single pattern
  * 
  * @author lw
  * 
  */
 class Single2 {
     private static Single2 INSTANCE;
 
     private static boolean isInstance;
 
     private Single2() {
         /* 此处的构造器被强化 */
         if (isInstance) {
             throw new RuntimeException("对象已经存在,无法创建第二个对象");
         }
         isInstance = true;
     };
 
     public static Single2 newInstance() {
         if (null == INSTANCE) {
             INSTANCE = new Single2();
         }
         return INSTANCE;
     }
 }
 
 /**
  * 枚举 Single pattern 这种方法在功能与公有域方法相近，但是它更简洁，无偿的提供了序列化机制
  * 绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候。 虽然这种方法没有广泛采用，但是单元素的枚举类型以及成为事件Singleton的最佳方法。
  * 
  * @author lw
  * 
  */
 enum Single3 {
 
     INSTANCE;
 
     public static Single3 newInstance() {
         return INSTANCE;
     }
 }