设计模式大集合

1 概述

1.1 意义：

设计模式是前人工作的总结和提炼。通常，被人们广泛流传的设计模式都是对某一特定问题的成熟的解决方案。如果能合理地使用设计模式，不仅能使系统更容易地被他人理解，同时也能使系统拥有更加合理的结构。项目做的非常大，非常复杂的时候，仍然能让你能掌控这些代码，不会让他们乱成一团。

设计模式可以让你知道在某些场景下如何来设计出适合场景的架子，因为经验不丰富，大部分程序员写的代码的可维护性是非常差的，基本上只是实现了功能，没有做其他的考虑，比如以后要加新功能，目前写的程序改怎么改，或者类之间的关系非常复杂，不熟悉代码的人，根本不能开发等问题。

1.2 要求：

学完设计模式，再看各种框架的源码，感受别人代码的美感，与实际体会设计模式的使用模式。

在系统的学习设计模式之后，我们需要达到3个层次：

1. 能在白纸上画出所有的模式结构和时序图；
2. 能用代码实现；如果模式的代码都没有实现过，是用不出来的；即所谓，看得懂，不会用；
3. 灵活应用到工作中的项目中；

1.3 UML结构

类的继承结构表现在UML中为：泛化(generalize)与实现(realize)：

泛化表示继承非抽象类：宝马——小汽车

实现表示继承抽象类：小汽车——车

聚合关系：表示整体由部分构成的语义；例如一个部门由多个员工组成；整体不存在了，部分仍然存在

组合关系：整体由部分构成的语义；比如公司由多个部门组成；如果整体不存在了，则部分也不存在了

关联关系：不同类的对象之间的结构关系；学生和学校就是一种关联关系；

依赖关系：描述一个对象在运行期间会用到另一个对象的关系；

1.4 GoF23 总览

创建型模式分为以下5种：

• 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
• 原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
• 工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
• 抽象工厂（Abstract Factory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
• 建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

结构型模式分为以下 7 种：

• 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
• 适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
• 桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。
• 装饰（Decorator）模式：动态地给对象增加一些职责，即增加其额外的功能。
• 外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
• 享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
• 组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

行为型模式 11 种：

• 模板方法（Template Method）模式：定义一个操作中的算法骨架，将算法的一些步骤延迟到子类中，使得子类在可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
• 策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
• 命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
• 职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
• 状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
• 观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
• 中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
• 迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
• 访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
• 备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
• 解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

1.6 设计模式源码分析(!!!)

设计模式学习参考：

• 抽象工厂模式（详解版） (biancheng.net)
• 一起学设计模式 - 适配器模式 - SegmentFault 思否

源码使用设计模式分析：

• 抽象工厂在Java源码中的应用 (biancheng.net)

2 设计模式的七大原则

我们先要写出低耦合高内聚的代码，在java中需要遵循如下原则：

1. 模块间的依赖通过抽象类或接口发生，实现类之间的依赖关系也是通过抽象类或接口产生（实现类之间不应发生直接的依赖关系），降低系统的耦合性
2. 接口或抽象不依赖于实现类，但实现类依赖接口或抽象类，实现类对系统需要的功能具体实现，提高类的内聚程度

总结：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。

设计原则	一句话归纳	目的
开闭原则	对扩展开放，对修改关闭	降低维护带来的新风险
依赖倒置原则	高层不应该依赖低层，要面向接口编程	更利于代码结构的升级扩展
单一职责原则	一个类只干一件事，实现类要单一	便于理解，提高代码的可读性
接口隔离原则	一个接口只干一件事，接口要精简单一	功能解耦，高聚合、低耦合
迪米特法则	只和朋友交流，不和陌生人说话	减少代码臃肿
里氏替换原则	不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义	防止继承泛滥
合成复用原则	尽量使用组合或者聚合关系实现代码复用，少使用继承	降低代码耦合

2.1 开闭原则

开闭原则（Open Close Principle）就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：使程序的扩展性好，易于维护和升级。

2.2 单一职责原则

每个类应该实现单一的职责，如若不然，就应该把类拆分。

2.3 里氏替换原则

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

2.4 依赖倒置原则

依赖倒转原则（Dependence Inversion Principle）是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

// “高层模块不应该依赖于低层模块，二者都应该依赖于抽象。”这一原则在分层架构模式中，得到了淋漓尽致地运用。
public class CarController{
    //通过依赖注入来指定实现类，而这里只写抽象类。——依赖于抽象而不依赖于具体
    CarService carService;
    public void run(){
        carService.run();
    }
}

2.5 接口隔离原则

接口隔离原则（Interface Segregation Principle），这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

在具体应用接口隔离原则时，应该根据以下几个规则来衡量。

• 接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
• 为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法

【例1】学生成绩管理程序。

分析：学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能，如果将这些功能全部放到一个接口中显然不太合理，正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中

2.6 迪米特法则

迪米特法则（最少知道原则）（Demeter Principle）,就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。比如代理模式、中介者模式。

【例1】明星与经纪人的关系实例。

分析：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如与粉丝的见面会，与媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则

2.7 合成复用原则

合成复用原则（Composite Reuse Principle）原则是尽量首先使用合成/聚合的方式，而不是使用继承。比如桥接模式。

通常类的复用可以分为继承和合成，继承复用虽然简单，但是存在很大的缺点：
 （1）耦合度高，父类代码的修改会影响到子类，不利于代码的维护。
 （2）破坏了类的封装性，因为继承会将父类的实现细节暴露给子类，所以又叫做 “白箱” 复用。
 （3）限制了复用的灵活性，从父类继承来的实现是静态的，在运行期是无法改变的

合成复用是将已有的对象作为新对象的成员对象来实现，新对象调用已有对象的功能，达到复用：
 （1）不会破坏封装性，因为新对象只能调用已有对象暴露出来的方法，所以又叫做 “黑箱” 复用
 （2）耦合度低，已有对象的变化对新对象的影响较小，可以在新对象的中，根据需要调用已有对象的一些操作。
 （3）复用的灵活性高，可以在代码的运行中，动态选择相同类型的其他具体类。

可以看出用继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。但如果改用组合关系实现就能很好地解决以上问题。

3 创建型模式：

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。

3.1 工厂方法模式

工厂模式的三种形态

• 简单工厂（Simple Factory）不属于23种设计模式。
• 工厂方法（Factory Method）
• 抽象工厂（Abstract Factory）

3.1.1 简单工厂模式

又称为静态工厂方法(Static Factory Method)模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

就是通过传入不同的参数，返回不同的实例。传入 A 返回白酒，传入 B 返回红酒

缺点：将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂，这一点与开闭原则是相违背的。

interface Animal{
    void run(String name );
}
//简单工厂模式
class AnimalFactory implements Animal{

    @Override
    public void run(String name) {
        if(name.equals("dog")){
            System.out.println("ddaada");
        }
        if(name.equals("pig")){
            System.out.println("jiajia");
        }
    }
}

实际应用：

1、JDK类库如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

public final static DateFormat getDateInstance();
public final static DateFormat getDateInstance(int style);
public final static DateFormat getDateInstance(int style,Locale locale);

2、Java加密技术

获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

创建密码器:

Cipher cp=Cipher.getInstance("DESede");

3.1.2 工厂方法模式。

使用了面向对象的多态性，将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

针对不同的产品（图片读取器）提供不同的工厂。

//产品
interface ImgReader{
    void read();
}
//不同的具体产品
class PngImgReader implements ImgReader{
    @Override
    public void read() {
        System.out.println("png图片格式阅读器");
    }
}
class JpgImgReader implements  ImgReader{
    @Override
    public void read() {
        System.out.println("jpg图片阅读器");
    }
}
//产品抽象工厂
interface ImgReaderFactory{
    ImgReader creat();
}
//针对不同的产品有不同的实现工厂
class PngImgReaderFactory implements ImgReaderFactory{
    @Override
    public ImgReader creat() {
        System.out.println("实例化png图片阅读器");
        return new PngImgReader();
    }
}

class JpgImgReaderFactory implements  ImgReaderFactory{
    @Override
    public ImgReader creat() {
        System.out.println("实例化jpg图片阅读器");
        return new JpgImgReader();
    }
}

@Test
public void test(){
    //1.创建具体工厂
    ImgReaderFactory pngImgReaderFactory = new PngImgReaderFactory();
    //2.具体化实例
    ImgReader reader = pngImgReaderFactory.creat();
    reader.read();
}

缺点： 每次需要编写新的对象和对象工厂类，随业务发展，一定程度上增加了系统复杂度

3.2 抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

【例1】用抽象工厂模式设计农场类。

分析：农场中除了像畜牧场一样可以养动物，还可以培养植物，如养马、养牛、种菜、种水果等，所以本实例比前面介绍的畜牧场类复杂，必须用抽象工厂模式来实现。

3.3 建造者模式

建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

建造者模式让我们写的代码更具可读性，可理解为建立复杂的物体。它往往是实现一个连贯的操作，从而更加直观。有时候构建一个复杂的对象，需要经过好几步的处理，比如常用的StringBuffer、StringBuilder、以及Swagger（一种接口文档），都是以这种模式构建对象的

如果将抽象工厂模式看成 汽车配件生产工厂 ，生产一个产品族的产品，那么建造者模式就是一个 汽车组装工厂 ，通过对部件的组装可以返回一辆完整的汽车。建造者是在最后的一步返回对象，而对于抽象工厂来说，对象是立即返回的。

实例：KFC套餐

建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、 可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。

如果你发现自己在一个情况下，你不断添加新参数的构造函数，使得代码变得容易出错，很难读，也许可以考虑使用一个Builder重构你的代码。当构造函数的参数太多、类型极容易混淆是可以构建者模式

public class Summoner {

    private String name;
    private String type;
    private String innate;

    private Summoner(Builder builder) {
        this.name = builder.name;
        this.type = builder.type;
        this.innate = builder.innate;
    }

    //建造者内部类
    protected static class Builder {
            private String name;
            private String type;
            private String innate;

            protected Builder name(String name) {
                this.name = name;
                return this;
            }

            protected Builder type(String type) {
                this.type = type;
                return this;
            }

            protected Builder innate(String innate) {
                this.innate = innate;
                return this;
            }
            protected Summoner build() { return new Summoner(this);}
        }
}

public class BuilderDemo {

    public static void main(String[] args) {
        Summoner monkey = new Summoner.Builder().name("孙悟空").type("上单").innate("战争雷霆").build();
        System.out.println(monkey.toString());
    }
}

3.4 单例模式

通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；

单例模式的要点有三个：

一是某个类只能有一个实例；

二是它必须自行创建这个实例；

三是它必须自行向整个系统提供这个实例。

Java中，单例模式主要分：懒汉式单例、DCL饿汉式模式(双重校验锁)、静态内部类、懒汉模式

//饿汉模式
public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }

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

//DCL懒汉
private volatile static LazyLoader lazyLoader;//防止指令重拍
public static LazyLoader getInstance() {
    if (lazyLoader == null) {
        synchronized (LazyLoader.class) {
            if (lazyLoader == null) {
                lazyLoader = new LazyLoader();
            }
        }
    }
    return lazyLoader;
}

//静态内部类
public class Holder {
    private Holder() {
    }

    public static Holder getInstance() {
        return InnerClass.holder;
    }

    private static class InnerClass {
        private static final Holder holder = new Holder();
    }
}

//枚举类
public enum EnumSingleton {
    INSTANCE;
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}

3.5 原型模式

复制现有的对象实例来创建新的对象实例。

原型模式的优点：

• Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
• 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

缺点：

• 通过内存拷贝的方式构建出来的，会忽略构造函数限制
• 需要注意深拷贝和浅拷贝，默认Cloneable 是浅拷贝，只拷贝当前对象而不会拷贝引用对象，除非自己实现深拷贝
• 与单例模式冲突，clone是直接通过内存拷贝的方式，绕过构造方法

实现Cloneable接口：

Cloneable接口的作用是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。

重写Object类中的clone方法：

Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，原型类需要将clone方法的作用域修改为public类型。

适用场景

• 常用在初始化步骤繁琐，资源耗损严重的对象

4 结构型模式

结构型模式描述如何将类或对象按某种布局组成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。

结构型模式可以分为类结构型模式和对象结构型模式，由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性：

• 类结构型模式中一般只存在继承关系和实现关系。

• 对象结构型模式关心类与对象的组合，在系统中尽量使用关联关系（不同类的对象之间的结构关系）来替代继承关系，大部分结构型模式都是对象结构型模式。

4.1 适配器模式

在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑接交流电源时需要一个电源适配器，类似type-c的转接口。在软件开发中采用类似于电源适配器的设计和编码技巧被称为适配器模式。

在适配器模式中可以定义一个包装类，包装不兼容接口的对象，这个包装类指的就是适配器(Adapter)，它所包装的对象就是适配者(Adaptee)，其别名为包装器(Wrapper)，即被适配的类。适配器提供客户类需要的接口，适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用

使用场景：相当于外面包一层

• 系统需要使用现有的类，而这些类的接口不符合系统的需要。
• 想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。

类适配器：

Java I/O 库大量使用了适配器模式，如 ByteArrayInputStream 是一个适配器类，它继承了 InputStream 的接口，并且封装了一个 byte 数组。换言之，它将一个 byte 数组的接口适配成 InputStream 流处理器的接口。

Advice（通知）的类型有：BeforeAdvice、AfterReturningAdvice、ThrowSadvice 等。每个类型 Advice（通知）都有对应的拦截器，MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor、ThrowsAdviceInterceptor。Spring 需要将每个 Advice（通知）都封装成对应的拦截器类型，返回给容器，所以需要使用适配器模式对 Advice 进行转换。

对象适配器：

//标准接口
interface  Target{
    void connect();
}
//特殊接口
class M5DataLine implements  Target{

    @Override
    public void connect() {
        System.out.println("M5连接器");
    }
}
// 创建适配器类，实现标准接口
class DataLineAdapter implements Target{
    private Target target;
   
    public DataLineAdapter(Target target) {
        this.target = target;
    }
   //将这个调用委托给实现新接口的对象来处理
    @Override
    public void connect() {
        System.out.println("转接口");
        target.connect();
    }
}

4.2 桥接模式

可以理解成原来由继承来实现不同功能的方式，这种紧耦合，及对于多个维度指数型增长的情况，利用桥接的方式松耦合，将抽象部分与它的实现部分分离，使它们都可以独立地变化。

桥接模式将继承关系转换为关联关系（不同类的对象之间的结构关系，内部属性），从而降低了类与类之间的耦合，减少了代码编写量。因为继承复用破坏包装，父类发生改变，则子类也要发生相应的改变，这就直接导致了类之间的紧耦合，不利于类的扩展、复用、维护。

//抽象部分与实现部分分离
interface Car{
    void run();
}

//将继承改为不同对象之间的结构关系
abstract class AbstractRoad{
    protected Car car;
    public AbstractRoad(Car car) { this.car = car; }
    public abstract void run();
}

//抽象类的分别实现部分，汽车类
class BusCar implements Car{
    @Override
    public void run() { System.out.println("公共汽车"); }
}

class smallCar implements Car{
    @Override
    public void run() { System.out.println("小汽车"); }
}

//道路类
class SpeedRoad extends AbstractRoad{

    public SpeedRoad(Car car) { super(car); }

    @Override
    public void run() {
        System.out.println("在高速公路");
        car.run();
    }
}

class StreetRoad extends AbstractRoad{

    public StreetRoad(Car car) {  super(car); }

    @Override
    public void run() {
        System.out.println("在市区街道");
        car.run();
    }
}
//测试类
public class Bridge {
    public static void main(String[] args) {
        BusCar bus = new BusCar();
        StreetRoad streetRoad = new StreetRoad(bus);
        streetRoad.run();
    }
}

桥接模式在JDBC中运用方式：

通常使用JDBC连接数据库时，首选就是加载数据库驱动，然后获取数据库连接

Class.forName("数据库类驱动器");
Connection conn = DriverManager.getConnection("数据库url", "用户名", "密码");
//.................

针对不同的数据库，JDBC都可以通过java.sql.DriverManager类的静态方法getConnection(数据库url, 用户名, 密码)来获取数据库的连接。JDBC通过DriverManager对外提供了操作数据库的统一接口getConnection，通过该方法可以获取不同数据库的连接，并且通过Connection类提供的接口来进行数据的查询操作。

JDBC为不同的数据库操作提供了相同的接口，但是JDBC本身并没有针对每种数据库提供一套具体实现代码，而是通过接口java.sql.Driver的connect方法连接到了不同的数据库实现。

public interface Driver {

    Connection connect(String url, java.util.Properties info) throws SQLException;
    //其他方法
}

在JDBC中，针对不同数据库提供的统一的操作接口通过java.sql.Driver（桥）连接到了不同的数据库实现。如连接mysql数据库。

package com.mysql.jdbc;

public class NonRegisteringDriver implements java.sql.Driver { 

    public java.sql.Connection connect(String url, Properties info) throws SQLException {
        //省略具体实现代码...
    }

    //其他方法
}

具体实现

1.在com.mysql.jdbc.Driver的源码中可以看到，类加载时会将Driver注册到DriverManager中。

package com.mysql.jdbc;

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

2.在DriverManager中，调用getConnection会迭代驱动注册表中的驱动，然后调用Driver接口提供的connect方法来获取Connection对象

public class DriverManager {

 // JDBC驱动程序注册表
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();


public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException {
    /* Register the driver if it has not already been added to our list */
    if(driver != null) {
        registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
    } else {
        // This is for compatibility with the original DriverManager
        throw new NullPointerException();
    }
    println("registerDriver: " + driver);
    }

private static Connection getConnection(String url, java.util.Properties info, Class<?> caller) throws SQLException {
    ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
    synchronized(DriverManager.class) {
        // synchronize loading of the correct classloader.
        if (callerCL == null) {
            callerCL = Thread.currentThread().getContextClassLoader();
        }
    }

    if(url == null) {
        throw new SQLException("The url cannot be null", "08001");
    }

    println("DriverManager.getConnection(\"" + url + "\")");

    SQLException reason = null;
    //遍历registeredDrivers表
    for(DriverInfo aDriver : registeredDrivers) {
        // 如果没有加载驱动的权限则跳过
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                //调用Driver接口提供的connect方法来获取Connection对象
                println("    trying " + aDriver.driver.getClass().getName());
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    // Success!
                    println("getConnection returning " + aDriver.driver.getClass().getName());
                    return (con);
                }
            } catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }

        } else {
            println("    skipping: " + aDriver.getClass().getName());
        }

    }

    // if we got here nobody could connect.
    if (reason != null)    {
        println("getConnection failed: " + reason);
        throw reason;
    }
    println("getConnection: no suitable driver found for "+ url);
    throw new SQLException("No suitable driver found for "+ url, "08001");
   }
 }
}

4.3 组合模式

组合模式将对象组织到树结构中，可以用来描述整体与部分的关系。类似于继承关系。将对象之间的关系组织成一棵树。

• 组合对象的关键在于它定义了一个抽象构建类，它既可表示叶子对象，也可表示容器对象，客户仅仅需要针对这个抽象构建进行编程，无须知道他是叶子对象还是容器对象，都是一致对待。

public interface Employee {
    void add(Employee employee);
    void remove(Employee employee);
    void print();
}

public class Developer implements Employee {
    private String name;
    private double salary;
    public Developer(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    @Override
    public void add(Employee employee) {
        //叶子节点，该方法不适用于当前类
    }
    @Override
    public void remove(Employee employee) {
        //叶子节点，该方法不适用于当前类
    }

    @Override
    public void print() {
        System.out.println("-------------");
        System.out.print("Name = " + this.name);
        System.out.println("\t\tSalary = " + this.salary);
        System.out.println("-------------");
    }
}

public class Manager implements Employee {
    private String name;
    private double salary;
    public Manager(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    private List<Employee> employees = new ArrayList<>();
    @Override
    public void add(Employee employee) {
        employees.add(employee);
    }
    @Override
    public void remove(Employee employee) {
        employees.remove(employee);
    }

    @Override
    public void print() {
        System.out.println("-------------");
        System.out.print("Name = " + this.name);
        System.out.println("\t\tSalary = " + this.salary);
        System.out.println("-------------");
        for (Employee employee : employees) {
            employee.print();
        }
    }
}

4.4 外观模式

外观模式（Facade Pattern）属于结构型模式的一种，为子系统中的一组接口提供一个统一的入口，它通过引入一个外观角色来简化客户端与子系统之间的交互

该模式应用其实非常之广泛：DAO->Service->Controller`

与适配器模式的区别

适配器模式是将一个对象包装起来以改变其接口，而外观模式是将一群对象包装起来以简化其接口。适配器是将接口转换为不同接口，而外观模式是提供一个统一的接口来简化接口。

4.5 享元模式

享元模式（Flyweight Pattern）属于结构型模式的一种，又称轻量级模式，通过共享技术有效地实现了大量细粒度对象的复用，这样设计的目的就是：为了避免在创建多相同对象时，所产生的不必要的资源消耗。

在Java中使用的情况非常多。比如各种包装类内部的情况！以及下面这种常量池模式。

public class Client {
    public static void main(String[] args) {
        String a = "盖伦";
        String b = "盖伦";
        System.out.println(a==b);// 返回 true
    }
}

4.6 代理模式

代理模式（Proxy Pattern）属于结构型模式的一种，给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。

案例：

• **静态代理：**代理类是在编译时就实现好的。Java 编译完成后代理类是一个实际的 class 文件。
• **动态代理：**代理类是在运行时生成的。编译完之后并没有实际的 class 文件，而是在运行时动态生成的类字节码，并加载到JVM中。

比较：

• 适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口
• 装饰器模式为了增强功能，而代理模式是为了加以控制。

4.7 装饰器模式

如果一有其他的需求就进行继承扩展。那久而久之就会出现类爆炸，所以我们需要减少类的数量。

1、目的：可以动态的为同一类的不同对象加以修饰以添加新的功能。

2、动机：灵活的对类对象功能进行扩展。

实例：

装饰器模式和代理模式的区别

1、装饰器模式强调的是增强自身，在被装饰之后你能够在被增强的类上使用增强后的功能。增强后你还是你，只不过能力更强了而已；代理模式强调要让别人帮你去做一些本身与你业务没有太多关系的职责（记录日志、设置缓存）。代理模式是为了实现对象的控制，因为被代理的对象往往难以直接获得或者是其内部不想暴露出来。

2、装饰模式是以对客户端透明的方式扩展对象的功能，是继承方案的一个替代方案；代理模式则是给一个对象提供一个代理对象，并由代理对象来控制对原有对象的引用；

//图像抽象基类
public interface Shape {
    void draw();
}
//图像实现类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.print("a circle!");
    }
}
//装饰器抽象类，注意实现了图像抽象类
public abstract class Decorator implements Shape {
    protected Shape circle;
    public Decorator(Shape shape) {
        circle = shape;
    } 
    public void draw() {
        circle.draw();
    }
}
//装饰器实现类1
public class CircleEdge extends Decorator {
    public CircleEdge(Shape circle) {
        super(circle);
    }
    private void setEdgeColor() {
        System.out.print(", edge with color");
    }
    public void draw() {
        circle.draw();
        setEdgeColor();
    }
}

//装饰器实现类2
public class CircleFill extends Decorator {
    
    public CircleFill(Shape circle) {
        super(circle);
    }
    private void setEdgeFill() {
        System.out.print(", content with color");
    }
    public void draw() {
        circle.draw();
        setEdgeFill();
    }
}

public class Demo {
    public static void main(String[] args) {
        Decorator circleFill = new CircleFill(circle);
        circleFill.draw();//a circle!, content with color
        Decorator circleEdgeFill = new CircleFill(circleEdge);
        //自由组合功能，就像自助一样自由搭配自由扩展
        circleEdgeFill.draw();//a circle!, edge with color, content with color
    }
}

5 行为型模式

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

5.1 模板方法模式

是基于继承的代码复用的基本技术。应用最为广泛

定义一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。

抽象类给出一个算法的轮廓和骨架，实现类负责给出这个算法的各个逻辑步骤。

// 抽象类，抽象出基本的方法
public abstract class Animal {
   public void eat();
   public void run();
   public void sleep();
}
// 实现类，根据具体的情况去实现这些基本的方法

5.2 策略模式

策略模式（Strategy Pattern）属于对象行为型模式的一种，其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换，“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。

实例，计算价格：

算法一：对初级会员没有折扣。

算法二：对中级会员提供10%的促销折扣。

算法三：对高级会员提供20%的促销折扣

策略模式的重心不是如何实现算法，而是如何组织、调用这些算法，从而让程序结构更灵活，具有更好的维护性和扩展性

5.3 状态模式

一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为

使用状态模式，可以很好地避免过多的if–else –分支，状态模式将每一个状态分支放入一个独立的类中，每一个状态对象都可以独立存在，程序根据不同的状态使用不同的状态对象来实现功能。

//  writeProgram() 方法中的代码过长，这通常不是一个好的代码，writeProgram()中不应该有太多的判断。这个方法很长，而且有很多判断分支，这就意味着它的责任过大了,违背了“单一职责原则”。无论任何状态，都需要通过它来改变，这实际上是很糟糕的。
public void writeProgram(){
        if (hour < 12){
            System.out.println("当前时间" + hour + "上午工作，精神百倍");
        } else if (hour < 13){
            System.out.println("当前时间" + hour + "饿了，午饭，犯困，休息");
        } else if (hour < 17){
            System.out.println("当前时间" + hour + "下午状态还不错，继续努力");
        } else {
            if (finish){
                System.out.println("当前时间" + hour + "下班回家了");
            } else if (hour < 21){
                System.out.println("当前时间" + hour + "加班哦，好难受");
            } else {
                System.out.println("当前时间" + hour + "不行了，睡着了");
            }
        }
    }

//把这些状态改成：抽象基类+具体实现类
public abstract class State {
    public abstract void writeProgram(Work work);
}
public class ForenoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 12){
            System.out.println("当前时间" + work.getHour() + "上午工作，精神百倍");
        } else {
            work.setState(new NoonState());
            work.writeProgram();
        }
    }
}
 
public class AfternoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 17){
            System.out.println("当前时间" + work.getHour() + "下午状态还不错，继续努力");
        } else {
            work.setState(new EveningState());
            work.writeProgram();
        }
    }
}
 
public class NoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 13){
            System.out.println("当前时间" + work.getHour() + "饿了，午饭，犯困，休息");
        } else {
            work.setState(new AfternoonState());
            work.writeProgram();
        }
    }
}
 
public class EveningState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.isFinish()){
            work.setState(new RestState());
            work.writeProgram();
        } else {
            if (work.getHour() < 21){
                System.out.println("当前时间" + work.getHour() + "加班哦，好难受");
            } else {
                work.setState(new SleepingState());
                work.writeProgram();
            }
        }
    }
}
 
public class RestState extends State {
    @Override
    public void writeProgram(Work work) {
        System.out.println("当前时间" + work.getHour() + "下班回家了");
    }
}
 
public class SleepingState extends State {
    @Override
    public void writeProgram(Work work) {
        System.out.println("当前时间" + work.getHour() + "不行了，睡着了");
    }
}

策略模式和状态模式的区别：

策略模式是让用户指定更换的策略算法，而状态模式是状态在满足一定条件下的自动更换，用户无法指定状态，最多只能设置初始状态。

1、状态模式重点在各状态之间的切换，从而做不同的事情；而策略模式更侧重于根据具体情况选择策略，并不涉及切换。

2、状态模式不同状态下做的事情不同，而策略模式做的都是同一件事。例如，聚合支付平台，有支付宝、微信支付、银联支付，虽然策略不同，但最终做的事情都是支付，也就是说他们之间是可替换的。反观状态模式，各个状态的同一方法做的是不同的事，不能互相替换。

3、状态模式封装了对象的状态，而策略模式封装算法或策略。因为状态是跟对象密切相关的，它不能被重用；而策略模式通过从Context中分离出策略或算法，我们可以重用它们

5.4 观察者模式

定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新

观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

实现的关键是要建立观察者和被观察者之间的联系、比如在被观察者类中有个集合是用于存放观察者的、当被检测的东西发生改变的时候就要通知所有观察者。在被观察者中要提供一些对所有观察者管理的一些方法.目的是添加或者删除一些观察者.这样才能让被观察者及时的通知观察者关系的状态已经改变、并且调用观察者通用的方法将变化传递过去。

在实现观察者模式，如果JDK的Observable类和一个Observer接口能满足需求，直接复用即可，无需自己编写抽象观察者、抽象主题类；

class Subject {
    /**
     * 用来保存注册的观察者对象
     */
    private List<Observer> observers = new ArrayList<>();

    /**
     * 注册观察者对象
     *
     * @param observer 观察者对象
     */
    void attach(Observer observer) {
        observers.add(observer);
    }

    /**
     * 通知所有注册的观察者对象
     */
    void notifyObservers(String newState) {
        for (Observer observer : observers) {
            observer.update(newState);
        }
    }
}

5.5 访问者模式

预留通路，回调实现。它的实现主要就是通过预先定义好调用的通路，在被访问的对象上定义accept方法，在访问者的对象上定义visit方法；然后在调用真正发生的时候，通过两次分发的技术，利用预先定义好的通路，回调到访问者具体的实现上

类似于把一溜相关的实现类放在一个map中，方法不变，调用时实现改变了

public class Client {

    public static void main(String[] args) {
        Home home = new Home();
        home.add(new Dog());
        home.add(new Cat());

        Owner owner = new Owner();
        home.action(owner);

        Someone someone = new Someone();
        home.action(someone);
    }

}
// 输出结果
主人喂食狗
好好吃，汪汪汪！！！
主人喂食猫
好好吃，喵喵喵！！！
其他人喂食狗
好好吃，汪汪汪！！！
其他人喂食猫
好好吃，喵喵喵！！！

5.6 中介者模式

对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂。如果其中一个类需要调用另一个类中的方法，我们可以通过第三方来转发这个调用。所以对于关系比较复杂的系统，我们为了减少对象之间的关联关系，使之成为一个松耦合系统，我们就需要使用中介者模式。

中介模式和代理模式的区别：

• 代理模式：一对一，这个代理只能代表一个对象；只能代理一方，类似于中间人的存在

• 中介模式：多对多，这些被管理的对象之间都可以通信，它们的业务关系应该是交织在一起的；A能够通过中介访问B，B也能够通过中介访问A；类似于联合国的存在

5.7 责任链模式

一个请求有多个对象来处理，这些对象形成一条链，根据条件确定具体由谁来处理，如果当前对象不能处理则传递给该链中的下一个对象，直到有对象处理它为止。责任链模式通过将请求和处理分离开来，以进行解耦。职责链模式结构的核心在于引入了一个抽象处理者。

职责链模式通过建立一条链来组织请求的处理者，请求将沿着链进行传递，请求发送者无须知道请求在何时、何处以及如何被处理，实现了请求发送者与处理者的解耦。在软件开发中，如果遇到有多个对象可以处理同一请求时可以应用职责链模式，例如在Web应用开发中创建一个过滤器(Filter)链来对请求数据进行过滤，在工作流系统中实现公文的分级审批等等，使用职责链模式可以较好地解决此类问题。

5.8 命令模式

作用：将“行为请求者”与“行为实现者”松耦合。比如从 看电视的人——电视机的紧耦合，转化成 看电视的人——遥控器——电视机的耦合。将原来调用行为实现者直接实现的方法，转化成中间节点以命令集合类的方式调用执行，实现松耦合。

缺点：缺点就是会有很多的命令实现子类

//行为请求者与行为者紧耦合情况
//电视机对象：提供了播放不同频道的方法
public class Television {
    public void playCctv1() {
        System.out.println("--CCTV1--");
    }
    public void playCctv2() {
        System.out.println("--CCTV2--");
    }
    ....
}
//看电视人类
public class Watcher {
    //直接持有一个行为执行者Television
    public Television tv;

    public Watcher(Television tv) {
        this.tv = tv;
    }
	//	使用时直接调用执行者的方法
    public void playCctv1() {
        tv.playCctv1();
    }
    public void playCctv2() {
        tv.playCctv2();
    }
    .....
}
//实现请求执行,Watcher类和Television完全的耦合,一动都要改动,不符合"对修改关闭，对扩展开放"原则
//并且无法实现调用的回退，记录调用的顺序
public static void main(String args[]) {
        Watcher watcher = new Watcher(new Television());
        watcher.playCctv1();
        watcher.playCctv2();
       .....
    }

//修改：抽象一个命令类
public abstract class Command {
    //命令接收者：电视机
    protected Television television;

    public Command(Television television) {
        this.television = television;
    }

    //命令执行
    abstract void execute();
}

//将所有调用转换成对应的命令类 //播放cctv1的命令
public class CCTV1Command extends Command {
    @Override
    void execute() {
        television.playCctv1();
    }
}

//播放cctv2的命令
public class CCTV2Command extends Command {
    @Override
    void execute() {
        television.playCctv2();
    }
}
。。。。。。。。

// 定义遥控器类
public class TeleController {
    //播放记录
    List<Command> historyCommand = new ArrayList<Command>();

    //切换卫视
    public void switchCommand(Command command) {
        historyCommand.add(command);
        command.execute();
    }

    //遥控器返回命令
    public void back() {
        if (historyCommand.isEmpty()) {
            return;
        }
        int size = historyCommand.size();
        int preIndex = size-2<=0?0:size-2;

        //获取上一个播放某卫视的命令
        Command preCommand = historyCommand.remove(preIndex);

        preCommand.execute();
    }

}

//使用命令模式之后的请求-执行操作
//创建一个电视机
Television tv = new Television();
//创建一个遥控器
TeleController teleController = new TeleController();

teleController.switchCommand(new CCTV1Command(tv));
teleController.switchCommand(new CCTV2Command(tv));
System.out.println("------返回上一个卫视--------");
//模拟遥控器返回键
teleController.back();
teleController.back();

命令模式和外观模式（Controller-Service-DAO）的区别：

命令模式像一个多按钮的遥控器，每个按钮是一个命令，调用方使用某些按钮进行开关操作，并且还支持等待执行的行为。命令模式能细粒度的控制每个按钮的执行顺序，执行是否撤回。

而外观模式则是更像遥控器上只有一个按钮，而这一个按钮执行多个设定好顺序的开关操作。并且中间不能撤回。外观模式无法穿透外观类（或接口）去细粒度的控制内部的执行顺序或某些特殊的逻辑。

5.9 备忘录模式

备忘录模式能记录一个对象的内部状态，当用户后悔时能撤销当前操作，使数据恢复到它原先的状态。

编辑时按Ctrl+Z组合键时能撤销当前操作，使文档恢复到之前的状态；还有在IE中的后退键、数据库事务管理中的回滚操作、玩游戏时的中间结果存档功能、数据库与操作系统的备份操作、棋类游戏中的悔棋功能等都属于这类。

理解：类似于备份一份copy版存储，所以相应的会有资源消耗。

5.10 迭代器模式

定义：将迭代这个方法从所有集合类中抽取出来，形成一个抽象接口。分离聚合对象和其遍历的行为，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

迭代器模式是针对集合对象而生的，对于集合对象而言，肯定会涉及到对集合的添加和删除操作，同时也肯定支持遍历集合元素的操作，我们此时可以把遍历操作放在集合对象中，但这样的话，集合对象既承担太多的责任了，面向对象设计原则中有一条就是单一职责原则，所有我们要尽可能地分离这些职责，用不同的类取承担不同的责任，迭代器模式就是用迭代器类来承担遍历集合的职责。

while (it.hasNext()) {
    Object ob = it.next();
    System.out.print(ob.toString());
}

// public interface Collection<E> extends Iterable<E>{}
public interface Iterable<T> {
    Iterator<T> iterator();//iterator方法用于返回一个实现了Iterator接口的对象
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

public interface Iterator<E> {
    boolean hasNext(); //每次next之前，先调用此方法探测是否迭代到终点
    E next(); //返回当前迭代元素 ，同时，迭代游标后移
    void remove();
}
//（1） 迭代器iterator是用来遍历集合中元素的工具。任何一个集合要想通过迭代的方式遍历元素则必须获得一个属于自身的迭代器；
//（2） 接口Iterable中提供了一种方法为iterator()，该方法用于返回一个实现了Iterator接口的对象，即返回一个迭代器；
//（3） 集合的基本接口Collection继承了接口Iterable，故所有直接或间接实现了接口Collection的集合类都是可迭代的，都可以通过调用.iterator()方法得到一个属于自身的迭代器

5.11 解释器模式

解释器模式（Interpreter），给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。完成了对语法的解析，将一个个的词组解释成了一个个语法范畴，之后拿来使用而已。

就比如正则表达式，它就是解释器模型的一种应用，解释器为正则表达式定义了一个文法，如何表示一个特定的正则表达式，以及如何解释这个正则表达式。

一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是a+b-c * d，有时是a * b+c-d，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式