2.5 万字详解：23 种设计模式

本文简述了各大设计模式，并通过UML和代码详细说明。本文大约共 2.5W 字，建议收藏。下方是本文的目录：

一、设计模式的认识

二、设计模式的分类

• 根据其目的

• 根据范围

三、设计模式的优点

四、设计模式中关键点

五、创建型模式

• 简单（静态）工厂模式

• 工厂方法模式

• 抽象工厂模式

• 单例模式

• 原型模式

• 建造者模式

六、个人体会

一、设计模式的认识

设计模式(Design Pattern)是前辈们经过相当长的一段时间的试验和错误总结出来的，是软件开发过程中面临的通用问题的解决方案。这些解决方案使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

二、设计模式的分类

（1）根据其目的

即模式是用来做什么的，可分为创建型(Creational)，结构型(Structural)和行为型(Behavioral)三种：①创建型模式主要用于创建对象。②结构型模式主要用于处理类或对象的组合。③行为型模式主要用于描述对类或对象怎样交互和怎样分配职责。

（2） 根据范围

即模式主要是用于处理类之间关系还是处理对象之间的关系，可分为类模式和对象模式两种：类模式处理类和子类之间的关系，这些关系通过继承建立，在编译时刻就被确定下来，是属于静态的。对象模式处理对象间的关系，这些关系在运行时刻变化，更具动态性。

三、设计模式的优点

①可以提高程序员的思维能力、编程能力和设计能力。②使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。③使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。现在这样说肯定有些懵逼，需要在实际开发中才能体会得到真正的好处。

四、设计模式中关键点

（1）创建型模式：简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。

抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。

建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。

单例模式：某个类只能有一个实例，提供一个全局的访问点。

原型模式：通过复制现有的实例来创建新的实例。

（2）结构型模式

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。

装饰模式：动态的给对象添加新的功能。

代理模式：为其他对象提供一个代理以便控制这个对象的访问。

适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。

亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。

（3）行为型模式模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。

策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。

状态模式：允许一个对象在其对象内部状态改变时改变它的行为。

观察者模式：对象间的一对多的依赖关系。

备忘录模式：在不破坏封装的前提下，保持对象的内部状态。

中介者模式：用一个中介对象来封装一系列的对象交互。

命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。

访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。

责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。

迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

五、创建型模式

（1）简单（静态）工厂模式

1.认识

①一句话来说就是，一个工厂类根据传入的参量决定创建出那一种产品类的实例。因为逻辑实现简单，所以称为简单工厂模式，也因为工厂中的方法一般设置为静态，所以也称为静态工厂，它不属于23种模式。

②简单工厂模式专门定义一个工厂类来负责创建其他类的实例，被创建的实例通常都具有共同的父类，在工厂类中，可以根据参数的不同返回不同类的实例。升级版本简单工厂模式，通过反射根据类的全路径名生成对象。

③简单工厂模式就是将这部分创建对象语句分离出来，由工厂类来封装实例化对象的行为，修改时只需要修改类中的操作代码，使用时调用该类不需要考虑实例化对象的行为，使得后期代码维护升级更简单方便，有利于代码的可修改性与可读性。

④但是如果增加新的产品的话，需要修改工厂类的判断逻辑，违背开闭原则。

2.UML图解

简单介绍一下UML：泛化：继承 带三角箭头的实线，箭头指向类

实现：实现 带三角箭头的虚线，箭头指向接口

依赖：new A的对象当作方法参数传递进来作为B类的局部变量 带箭头的虚线，指向被使用者

关联：一个类作为另一个类的成员变量 带普通箭头的实心线，指向被拥有者

聚合：new A的对象当作方法参数传递进来作为B类的成部变量 带空心菱形的实心线，菱形指向整体

组合：new A的对象当作构造方法参数传递进来作为B类的成部变量或者A类作为B类成 员变量并已经new A（A类和B类具有相同的生命周期） 带实心菱形的实线，菱形指向整体 总结：各种关系的强弱顺序：泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖

区分：①如果B类作为了A类的成员变量（has的关系），则一般是A类与B类是关联(A类与B类平级)、聚合（A类是整体，B类是部分）、组合的关系（A类是整体，B类是部分，且A类B类有相同的生命周期，）根据上下文语意区分：

聚合（B类即便不在A类中也可以单独存在），组合（B类不在A类中就无法单独存在）。②如果B类作为了A类的局部变量（use的关系），方法的形参，或者对静态方法的调用一般是依赖关系。UML类图如下：

UML说明：苹果手机和红米手机继承了手机这个抽象类，工厂类里根据客户端传入的参数生成相应的对象，如，客户说要红米，工厂给客户一个红米手机，客户说要苹果，工厂给客户一个苹果手机。

简单工厂有三个对象：①抽象产品类：提供抽象方法供具体产品类实现 ②具体产品类：提供具体的产品 ③工厂：根据内部逻辑返回相应的产品

3.代码实现

（1）抽象产品类Phone 这里可以是类，也可以是接口或者抽象类，千万不要思维定式。我比较喜欢面向接口编程，所以我这里用了接口。

public interface Phone {
     void produce();
}

（2）具体产品类

在这里插入代码片public class ApplePhoneImpl implements Phone{
    @Override
    public void produce() {
        System.out.println("生产苹果手机");
    }
}

public class RedmiPhoneImpl implements Phone{
    @Override
    public void produce() {
        System.out.println("生产了红米手机");
    }
}

（3）工厂类

public class Factory {
    
    public Phone getPhone(String type){
        Phone phone = null;
        if("红米".equals(type)){
            phone = new RedmiPhoneImpl();
        }else if("苹果".equals(type)){
            phone = new ApplePhoneImpl();
        }//.....
        return phone;
    }
}

（4）客户端使用

@Test
    public void test1(){
        Factory factory = new Factory();
        
        Phone redmiPhone = factory.getPhone("红米");
        System.out.println(redmiPhone);
        redmiPhone.produce();

        Phone applePhone = factory.getPhone("苹果");
        System.out.println(applePhone);
        applePhone.produce();
    }

运行结果如下：

4.总结

优点：只需要传入一个正确的参数，就可以获取你所需要的对象而无需知道其创建对象的细节

缺点：扩展性差，当增加新的产品需要修改工厂类的判断逻辑，违背开闭原则，如我想要买一个华为手机的话，除了新增华为手机这个产品类，还需要修改工厂中的逻辑

5.升级版本

通过反射创建对象，以改进了之前提到的缺点（增加新的产品需要修改工厂类的判断逻辑），现在增加新的具体产品的时候不需要修改工厂中的代码。满足了开闭原则。（1）工厂类代码如下：

public class FactoryPlus {
    public Phone getPhone(Class clazz) throws Exception {
        return (Phone) Class.forName(clazz.getName()).newInstance();
    }
}

（2）客户端代码如下：

@Test
public void test2() throws Exception {
        FactoryPlus factory = new FactoryPlus();

        Ph