设计模式中的单例设计模式

单例：单个实例

单例模式保证只有一个实例，就是要保证外界不能随便new这个对象，所以就要私有化构造方法。

私有化构造方法就是把new这个对象的控制权回收了，只能在类的内部去实例化这个对象，让类自身负责保存他的唯一实例。

单例模式的应用十分广泛，比如

Windows系统中的任务管理器，我们是不能同时打开两个任务管理器的。

Windows系统的回收站，也是只能打开一个的。

具体怎么实现呢？

目前有两种实现方法：

饿汉式：

顾名思义，饿汉，很饿比较饥渴，就是对象还没有开始使用就已经创建好了，什么时候用直接拿过来用

懒汉式：

懒汉，比较懒，我先不给你创建对象，你什么时候用我再什么时候跟你创建

饿汉式与懒汉式的区分：

饿汉式：

从线程安全上看：饿汉式是线程安全的

从时间空间上看：饿汉式是以空间换时间，意思就是还没用就把对象创建好，会长时间占用内存空间，但是效率要比懒汉式高

懒汉式：

从线程安全上看：懒汉式是线程不安全的（所以需要加锁）

从时间空间上看：懒汉式是以时间换空间，意思就是延迟对象的创建，内存空间占用时间短，但是效率要比饿汉式低

具体的代码实现如下：

饿汉式：

//饿汉式实现方法
class Bank{
    //1.要求私有化类的构造器 不让在类的外面创建类的对象
    private  Bank(){

    }

    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public  static Bank getInstance(){
        return instance;
    }

public class SingletonTest1 {
    public static void main(String[] args) {

        //创建一个测试类，创建两个对象，比较两个对象的值是否相等，如果相等，则为单例模式
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);

    }
}

懒汉式：

//懒汉式的实现
class Order{

    //1.私有化类的构造器
    private  Order(){

    }

    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    //双重加锁，保证线程安全
    public static Order getInstance(){
        if (instance == null){
            synchronized (Order.class){
                if (instance == null){
                    instance = new Order();
                }
            }

        }
        return instance;



    }
}

public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);
    }


}