Java设计模式之单例模式

单例模式

意图：保证一个类只有一个实例，并提供一个访问它的全局访问点
主要解决：一个全局使用的类频繁地创建与销毁
优点：在内存中只有一个实例，减少了内存的开销
缺点：不能继承，类的职责太重，与单一职责原则冲突
注意：

1. 提供一个自身的静态私有成员变量
2. 单例类的构造函数是私有的
3. 提供一个共有的静态工厂方法

创建一个IdentityCardNo类

public class IdentityCardNo {
    private String no;
    private static IdentityCardNo instance = null;
    // 单例类的构造函数是私有的
    private IdentityCardNo() {}

    public static IdentityCardNo getInstance() {
        if (instance == null) {
            System.out.println("第一次办理身份证，分配新的号码！");
            instance = new IdentityCardNo();
            instance.setNo("99257");
        } else {
            System.out.println("重复办理身份证，使用旧的号码！");
        }
        return instance;
    }

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }
}

创建一个Clinent类

public class Client {
    public static void main(String[] args) {
        IdentityCardNo no1,no2;
        no1 = IdentityCardNo.getInstance();
        no2 = IdentityCardNo.getInstance();

        System.out.println("身份证号是否一致：" + (no1==no2));

        String str1,str2;
        str1 = no1.getNo();
        str2 = no2.getNo();
        System.out.println("内容是否相等：" + str1.equalsIgnoreCase(str2));
        System.out.println("是否是同一个对象：" + (str1==str2));
    }
}

/* 输出
	第一次办理身份证，分配新的号码！
	重复办理身份证，使用旧的号码！
	身份证号是否一致：true
	内容是否相等：true	
	是否是同一个对象：true
*/

1、懒汉式

public class LazySingleton {

    private static LazySingleton instance = null;

    private LazySingleton() {
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

2、饿汉式

public class EagerSingleton {

    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

懒汉式和饿汉式单例的区别：
1、饿汉式单例直接创建对象
2、懒汉是单例需要先判断对象是否为空，再决定是否创建对象