JAVA设计模式之单例模式

单例模式——确保对象的唯一性。

下面有四种方法实现单例模式并做了验证。

1.普通的单例模式

//普通的单例模式，将构造函数设置为private，singleton = null在getSingleton()方法判断是返回已有的实例化对象还是新建对象
public class Singleton {
    private String otherProperty;

    private static Singleton singleton = null;

    private Singleton(){
        this.otherProperty="初始化对象的属性";
    }

    public static Singleton getSingleton(){
        if (singleton==null){
            return singleton=new Singleton();
        }
        return singleton;
    }
    public static void main(String[] args) {
        Singleton s1,s2;
        s1=Singleton.getSingleton();
        s2=Singleton.getSingleton();
        System.out.println(s1==s2);//输出true
    }
}

2.懒汉式单例模式

//懒汉式,其实普通的单例模式也是懒汉式，不过本类进行了增强
public class LazySingleton {
    private String otherProperty;

    private volatile static LazySingleton lazySingleton = null;

    private LazySingleton(){
        this.otherProperty="初始化别的属性";
    }

    public static LazySingleton getLazySingleton(){
        if (lazySingleton==null){
            synchronized(LazySingleton.class){
                if (lazySingleton==null){
                    return lazySingleton=new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }

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

3.饿汉式单例模式

//饿汉式单例模式
// private static EagerSingleton eagerSingleton = new EagerSingleton(),在类加载的时候就已经初始化对象eagerSingleton
public class EagerSingleton {
    private String otherProperty;

    private static EagerSingleton eagerSingleton = new EagerSingleton();

    private EagerSingleton(){
        this.otherProperty="初始化别的属性";
    }

    public static EagerSingleton getEagerSingleton(){
        return eagerSingleton;
    }

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

4.增强型

//增强型单例模式IoDH
//饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控
//制烦琐，而且性能受影响
public class SuperSingleton {
    private String otherProperty;

    private SuperSingleton(){
        this.otherProperty="初始化对象的属性";
    }

    private static class HolderClass{
        private static SuperSingleton superSingleton = new SuperSingleton();
    }

    public static SuperSingleton getSuperSingleton(){
        return HolderClass.superSingleton;
    }

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