常见的设计模式（超详细）

单例模式

确保一个类只有一个实例，并且自行实例化并向整个系统提供这个实例。

饿汉式单例模式

饿汉式单例模式在类加载的时候完成了实例化，因为我们将构造函数设为了私有，所有其他的对象不能通过new类创建这个类的实例，然后提供了一个公共的静态方法返回这个类的唯一实例。因为只有一个实例化对象，所以不存在线程安全问题，在平时不能通过new进行对象的创建，只能通过给定的那个全局访问点通过类名进行调用

/**
 * 饿汉式单例模式
 */
public class SingletonPattern {

    // 在类加载时完成了实例化
    private static SingletonPattern singletonPattern = new SingletonPattern();

    // 私有化构造函数，防止其他对象使用new创建该类的对象
    private SingletonPattern() {
    }

    // 提供一个公共的静态方法，返回该类的唯一实例
    public static SingletonPattern getSingletonPattern() {
        return singletonPattern;
    }
}

---

---

懒汉式单例模式

懒汉式单例在类加载的时候不创建对象，在第一次使用的时候进行创建，这样创建的优点是如果该单例对象在系统中没有被使用，那么就不会造成资源的浪费。但是懒汉式单例会出现线程安全问题，当多线程访问时，有可能出现多个线程同时if，就会创建出多个对象。

/**
 * 懒汉式单例模式
 */
public class SingletonPattern1 {

    // 初始化一个null对象
    private static volatile SingletonPattern1 singletonPattern = null;

    // 私有化构造函数，防止别的对象使用new创建该类的对象
    private SingletonPattern1() {
    }

    // 提供一个公共的静态方法，返回该类的唯一实例
    public static SingletonPattern1 getSingletonPattern() {
        if (singletonPattern == null) {
            singletonPattern = new SingletonPattern1();
        }
        return singletonPattern;
    }
}

---

要解决这个线程安全的问题可以有两种方式，第一种是给方法加锁，但是给方法加锁之后一次只能获取到一个线程，效率较低。第二种是给代码块加锁，需要使用双重检索

双重检索单例模式

既提高了效率，又提高了安全性，使用双重if的原因是，当只有一个if时，如果锁加载if代码块的外面，这时候和加载方法上是一样的，效率低；如果加在if内，这是后如果并发量大，几个线程同时进行if然后进入if，虽然内部代码被锁包裹，但是已经进入的线程一个接一个执行，仍然会创建出多个对象，此时需要给内部代码块再加一层if，这时候即提高了效率，又提高了安全性。

/**
 * 双重检索单例模式
 */
public class SingletonPattern2 {

    // 初始化一个null对象
    private static SingletonPattern2 singletonPattern = null;

    // 私有化构造函数，防止别的对象使用new创建该类的对象
    private SingletonPattern2() {
    }

    // 提供一个公共的静态方法，返回该类的唯一实例
    public static SingletonPattern2 getSingletonPattern() {
        if (singletonPattern == null) {
            synchronized (SingletonPattern2.class) {
                if (singletonPattern == null) {
                    singletonPattern = new SingletonPattern2();
                }
            }
        }
        return singletonPattern;
    }
}

---

此时问题并没有完全解决，我们知道一个对象创建的过程主要分为三步，分配内存，初始化对象，指向刚分配的地址，但是第二步和第三步由于CPU的优化，可能会产生排序，我们一般认为执行顺序为123，但是可能会先执行3再执行2，这时候的对象是一个半成品对象，但是也不是null所以此时的情况并没有完全解决，需要添加volatile，只有当所有步骤都执行完之后才会将对象的地址传给引用参数。

工厂模式

简单工厂模式

简单工厂模式又称为静态工厂方法模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责其他类的实例，被创建的实例通常都具有共同的父类。优点是实现对象的创建和使用分离，创建完全交给专门的工厂类去负责，程序员不关心怎么创建，只关心怎么使用。缺点是工厂类不够灵活，如果新增一个产品就要修改工厂类，就要修改它的判断逻辑，如果产品很多的话，这个逻辑就会非常复杂。比如就是一台咖啡机可以理解为一个工厂模式，你只需要按下想喝的咖啡品类的按钮，他就会给你生产一杯相应的咖啡，你不需要管他的内部具体实现，只需要告诉它你的需求。

工厂（方法）模式

简单工厂模式当有新产品加入时必须要修改工厂类，需要在其中加入必要的业务逻辑，这违反了开闭原则，没有办法做到灵活扩展。工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化那个类。工厂方法使一个类的实例化延迟到其子类。

在工厂模式中，之前的核心工厂变成了一个抽象接口，负责给出工厂应该实现的方法，它不在负责所有产品的创建，将具体产品的创建交给子类去做，这样就诞生了具体的子工厂，子工厂即子类，负责生成具体的产品对象，这样做可以将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类，在现在的工厂模式中，如果需要新增一个产品，不需要修改原有的工厂类逻辑，但是需要新增一个工厂，这样看起来比较复杂，但是在面向对象语言中，需要遵循开闭原则，就是程序对于扩展是开放的，对于修改时封闭的

Collection就是一个常见的工厂方法模式，其中Collection就是抽象工厂，具体工厂时LinkedList和ArrayList，抽象产品就是Iterator，具体产品就是ListItr和Itr。

抽象工厂模式

抽象工厂模式可以使具体工厂类，可以创建多个大类对象，但是还需要修改抽象工厂和具体工厂的代码，违反开闭原则。

原型模式

原型模式属于创建型模式，用来创建一个已有的对象的完全相同的复制品。这个时候如果直接复制的话，需要创建一个相同类的对象，然后遍历原始对象的所有成员变量以及所有属性，然后将这些变量的值复制到新的对象中，但是这个对象的某些成员变量是私有的，不对外公开，或没有提供访问器，那么外部是没有办法去复制的，并且对象实现的某个接口传给我们时，我么你只知道它的某个接口的实现类，他具体的类是哪一个，这是不知道的。那么原型模式就是去解决复制对象的问题的，原型模式将这个复制过程称之为克隆，原型模式就是将这个克隆的过程委派给被克隆的实际对象，由这个被克隆的对象自己去负责克隆，原型模式为所有被克隆的对象提供了一个通用接口，原型对象需要克隆的话就去实现这个接口（clone），就在克隆方法中去实现自己的克隆逻辑。

代理模式

代理模式就是为其他对象提供一种代以控制这个对象的访问。例：黄牛买票，婚介

代理模式分为静态代理和动态代理，动态代理又分为JDK代理和CGLIB动态代理

优点是代理模式能够协调调用者和被调者，在一定程度上降低系统的耦合度，并且可以灵活的隐藏被代理对象的部分功能和服务，也增加了额外的功能和服务，缺点就是使用代理模式程序没有直接调用性能高，并且使用代理模式提高了代码的复杂度。