用私有构造器或者枚举类型强化Singleton属性

     1.Singleton指仅仅被实例化一次的类。Singleton通常被用来代表那些本质上唯一的系统组件，如窗口管理器或者文件系统。使类称为Singleton会使它的客户端调试变的十分困难，因为无法给Singleton替换模拟实现，除非它实现一个充当其类型的接口.
     2.在Java1.5发行版本之前，实现Singleton有两种方法。这两种方法都要把构造器保持为私有，并导出公有的静态成员，以便客户端能够访问该类的唯一实例,以便允许client能够访问该类的唯一实例。
     3.第一种方法中，公有静态成员是个final域:
      public class Singleton1
   {
    public static final Singleton1 INSTANCE = new Singleton1();
    //私有改造函数
    private Singleton1()
    {
    }
    //其他方法实现
    public void otherMethod()
    {
     //...
    }
   }
   私有构造器仅被调用一次，用来实例化公有的静态final域Singleton1.INSTANCE.由于缺少公有的或者受保护的构造器，所以保证了Singleton1的全局唯一性。一旦其被实例化，只会存在一个实例，不多也不少。客户端的任何行为都不会改变这一点。
       注：享有特权的client可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器。如果要抵御这种攻击，需要修改构造器，让其在创建第二个实例的时候抛出异常。
      4.在实现Singleton的第二种方法中，公有的成员是个静态工厂方法:
   public class Singleton2
   {
    //私有static Instance
    private static final Singleton2 INSTANCE = new Singleton2();
    
    //私有构造函数
    private Singleton2()
    {
    }
    
    //获取单例方法
    public static Singleton2 getInstance()
    {
     return INSTANCE;
    }
    
    //其他方法
    public void otherMethod()
    {
     //...
    }
   }
   对于静态方法Singleton2.getInstance的所有调用，都会返回同一个对象引用，所以永远不会创建其他的实例。
   注：上述利用反射的提醒依然适用。
      5.公有域方法的好处在于，组成类的成员的声明很清楚的表明了这个类是一个Singleton（final），公有的静态域是final的，所以该域将总是包含相同的对象引用。公有域方法在性能上不再有任何优势：现在JVM实现几乎都能都将静态工厂方法的调用内联化。
      注：内联:指函数在被调用的地方直接展开，编译器在调用时不用像一般函数那样，参数压栈，返回时参数出栈以及资源释放等，这样提高了程序执行速度.
      6.工厂方法的优势在于，它提供了灵活性：在不改变其API的前提下，我们可以改变该类是否为Singleton的想法。工厂方法返回该类的唯一实例，不过它可以很容易被修改，如改成为每个调用该方法的线程返回一个唯一的实例。
       第二个优势在于与泛型有关。
       这些优势之间通常不相关，public域的方法比较简单.
      7.以上的两种的其中一种方法实现的Singleton类如果变成是可序列化的Serialiazble，仅仅在声明加上implements Serializable是不够的。为了维护并保证Singleton，必须声明所有实例都是瞬时transient的，并提供 一个readResolve方法。否则每次反序列化一个序列化的实例时，都会创建一个新的实例。即会导致一个假冒的对象。为了防止这种情况，需要在单例类中增加readResolve方法->
       注：readResolve方法用来重新指定反序列化得到的对象.
   private Object readResolve()
   {
    return INSTANCE;
   }
      8.从Java 1.5发行版本起，实现Singleton还有第三种方法。只需编写一个包含单个元素的枚举类型。
  public Enum Singleton3
  {
   INSTANCE;
   
   public void otherMethod()
   {
   }
  }
      这种方法在功能上与公有域方法相近，但是其更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是面对复杂的序列化或者反射攻击的时候。 虽然这种方法还没有广泛使用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。
      注：用反射调用私有构造函数:报错:
       Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects.
       ps:枚举真心不错.

部分源码:

package com.book.chap2.singleton;

import java.lang.reflect.Constructor;

/**
 * 
 * 单例实现1
 * <p>
 * 公有静态成员是个public final域
 * <p>
 * 为防止client利用反射调用私有改造函数，所以在创建第二个实例的时候抛出了异常
 * 
 * @author landon
 * @since 1.6.0_35
 * @version 1.0.0 2013-1-9
 * 
 */

public class Singleton1
{
    public static final Singleton1 instance = new Singleton1();

    // 私有改造函数
    private Singleton1()
    {
        if (instance != null)
        {
            throw new IllegalArgumentException("No exist the second instance");
        }
    }

    // 其他方法实现
    public void otherMethod()
    {
        // 
        System.out.println("call otherMethod");
    }

    @SuppressWarnings("rawtypes")
    public static void main(String args) throws Exception
    {
        Singleton1 singleton = Singleton1.instance;
        singleton.otherMethod();

        // 利用反射调用私有构造器
        Constructor[] arrayConstructor = singleton.getClass()
                .getDeclaredConstructors();
        for (Constructor constructor : arrayConstructor)
        {            // 调用setAccessible(true);            constructor.setAccessible(true);            // 实例化,这里一定会抛出异常            constructor.newInstance();        }    }}

package com.book.chap2.singleton;

import java.io.Serializable;

/**
*
*单例实现2
*<p>公有的成员为静态工厂方法
*<p>序列化时，要实现readResolve方法，防止反序列化出新的实例
*
*@author landon
*@since 1.6.0_35
*@version 1.0.0 2013-1-9
*
*/

public class Singleton2 implements Serializable
{
    //私有static Instance
    private static final Singleton2 INSTANCE = new Singleton2();
   
    //私有构造函数
    private Singleton2()
    {
    }
   
    //获取单例方法
    public static Singleton2 getInstance()
    {
        return INSTANCE;
    }
   
    //其他方法
    public void otherMethod()
    {
        //
    }
   
    //必须提供该方法，以便重新指定反序列化得到的对象.
    private Object readResolve()
    {
        return INSTANCE;
    }
}

package com.book.chap2.singleton;

import java.lang.reflect.Constructor;

/**
*
*枚举实现单例
*<p>目前最好的方式，避免了反射的攻击和序列化的问题
*
*<pre>
*反射调用枚举私有构造函数测试结果:
*    Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Unknown Source)
    at com.book.chap2.singleton.Singleton3.main(Singleton3.java:34)
*</pre>
*
*@author landon
*@since 1.6.0_35
*@version 1.0.0 2013-1-9
*
*/

public enum Singleton3 {
    INSTANCE;
   
    public void otherMethod()
    {
    }
   
    public static void main(Stringargs) throws Exception
    {
        //测试，是否可以反射生成枚举
        // 利用反射调用私有构造器
        Constructor[] arrayConstructor = Singleton3.INSTANCE.getClass().ge        tDeclaredConstructors();
for (Constructor constructor : arrayConstructor)
        {
            // 调用setAccessible(true);
            constructor.setAccessible(true);

            // 实例化,这里一定会抛出异常
            constructor.newInstance();
        }
    }

}