目的

确保类只有唯一实例。

实现

public class SingletonPattern {
    private static SingletonPattern singletonPattern = null;
    public static SingletonPattern getInstance(){
        if(singletonPattern == null){
            return new SingletonPattern();
        }
        return singletonPattern;
    }
    private SingletonPattern() {
    }
    //  方法
    public void display(){
        System.out.println("我是单例模式");
    }
}

注意点

（1）构造函数的可见性应为private，从而禁止外部类通过new创建对象。

（2）通过声明静态私有变量保存该类的唯一实例。

（3）通过静态方法getInstance创建该类的唯一实例。

饿汉式单例

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();
    private EagerSingleton() {
    }
    public static EagerSingleton getInstance(){
        return instance;
    }
}

特点：在类加载时就创建了单例对象。

懒汉式单例

给出了双重检查锁定实现的懒汉式单例类：

public class LazySingleton {
    private volatile static LazySingleton lazySingleton = null;
    private LazySingleton() {
    }
    public static LazySingleton getInstance(){
        //  第一重判断
        if(lazySingleton == null){
            //  锁定代码块
            synchronized (LazySingleton.class){
                //  第二重判断
                if(lazySingleton == null){
                    lazySingleton = new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }
}

在第一次调用getInstance()方法时实例化，在类加载时并不自 行实例化（延迟加载）。

饿汉式单例类与懒汉式单例类比较

更好的单例模式（IoDH）

要点：在单例类中增加一个静态内部类，在这个内部类中创建该单例类的唯一实例。

public class Singleton {
    private Singleton() {
    }
    private static class HolderClass{
        private final static Singleton singleton = new Singleton();
    }
    public static Singleton getInstacne(){
        return HolderClass.singleton;
    }

    public static void main(String[] args) {
        Singleton s1,s2;
        s1=Singleton.getInstacne();
        s2=Singleton.getInstacne();
        System.out.println(s1 == s2);
    }
}

由于静态单例对象没有作为成员变量，使得类加载时并不会实例化，而是在调用getInstacne方法时才实现第一次实例化

该方式实现的单例模式即实现了延迟加载，又保证了线程安全。