设计模式笔记

本内容主要是随笔笔记，里面有很多错误。仅供参考！！

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。主要是为了解耦

1. 创建型模式
   这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

2. 结构型模式
   这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

3. 行为型模式
   这些设计模式特别关注对象之间的通信。

责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

4. J2EE 模式
   这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。

MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）

1、简单工厂模式。

顾名思义，工厂就是生产用的，这里用来根据需求实例化对象的，主要用到了多态。简单讲，为了提高代码的复用率等，首先会有一个父类，封装公共的属性、变量及函数；然后利用继承的方式，对相似任务的类来继承同一个父类。
比如有父类A，针对不同的任务有两个子类a1和a2，他们同时继承了父类A。这里在声明类的时候要对a1和a2的具体函数进行完善。
在实例化的时候，需要根据需求选择实例化a1还是a2。我们可以在主程序中通过判断语句选择不同的类a1、a2进行实例化，但是为了方便，可以将这个实例化的过程封装为一个类，这个类就是工厂类。在这个类中只需要输入：不同的子类名称，就会返回：实例化后的对应的子类对象，就像一个工厂进行生产一样，所以称为工厂模式。

核心：就是建立一个工厂类，实现选择不同子类，并返回对应实例化对象的功能

在修改某个子功能时，可以通过修改对应子类完成（如a1）,当添加新的功能时，只需要添加新的子类（如a3）并在工厂的类中添加上就行。这样将任务进行一定的解耦，方便程序的维护。

2、工厂方法模式

简单工厂模式将工厂类中必要的逻辑判断包含进去，但是在添加新的方法时需要对工厂类进行更改，因此不符合开放-封闭原则。
包括四类：
1、抽象产品：定义产品的规范，是一个抽象类，比如：家电
2、具体产品：是抽象产品的实例，包括各种不同的产品的具体生产过程，比如：冰箱、电视、洗衣机等
3、抽象工厂：提供创建产品的结构，通过访问抽象产品类来创建产品，比如：家电生产厂
4、具体工厂：是抽象工厂的实例，完成具体产品的创建，主要是访问具体产品类，比如：美的工厂来生产冰箱，格力工厂生产电视等。

总结：抽象产品和具体产品负责产品的实际生产实现的过程，抽象工厂和具体工厂则是通过调用具体产品类来实现不同工厂对不同产品的生产。这样可以通过更改工厂类实现对不同产品的生产。

3、抽象工厂模式

相比工厂方法模式，只有一个工厂，抽象工厂模式时将工厂方法模式又抽象了出来，这样就可以又多个工厂，同时创建一个工厂生成器来根据信息生产指定的工厂，相当与在工厂方法上又嵌套了一层。
例如上面只有家电生产厂，现在又有了汽车生产厂，就抽象出一个生产厂，并实例化不同的生产厂，并通过生产厂生产器来生成不同类型的生产厂。

4、策略模式

在面对多种有相似功能的类时，（这些类用于处理相同问题，只是具体行为不同，他们可以互相替代，比如：健身时有跑步、跳绳等类，他们目的都是健身，只是具体行为方式不同），实用if else 不容易维护，扩展也不方便，所以可以创建一个类将不同的行为封装在一起，一般命名为context类，输入：不同的策略类，输出：共有的行为结果。
核心：构建一个context类从更上层来维护不同的策略，封装了不同策略的变化

比如：健身问题，
抽象父类：运动类，共同目的为：返回消耗的能量
子类有：跑步、跳绳等，继承运动类，他们的具体行为有差异。

策略模式中，构建context类：
声明一个具体对象（运动类）；初始化时输入要选择的具体的对象（如跑步）；创建一个函数来调用具体对象的具体方法（如返回消耗的能量）。

简单工厂模式和策略模式的结合

具体方法：在context类中的构造方法中，输入具体的策略方法（不是具体的实例，是区分不同方法的代号，比如可以是字符串）后，直接实例化对应的策略对象。相当于在这个类中完成了实例化工作（工厂模式的核心特点）。

5、装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

应用场景：想给一个对象添加一些额外功能时，一般的可以使用继承的方法构建子类，每种子类对应一个可能。随着扩展功能的增多，子类会出现爆炸现象。
比如：基础对象A，具有1特性时构建A1子类，有2特性时构建A2子类，有3特性时构建A3子类。此时如果有一个A既有1特性又有2特性时，就需要构建一个新的子类来表示。随着特性的增多，极有可能发送爆炸现象。
此时可以用装饰器模式来动态的扩展子功能。

思想是：构建一种结构，可以在原来的结构基础上增加新的属性。比如对象A，有1，2，3三种属性，可以通过一种方式进行属性的叠加，类似A12=A+1+2这种叠加结构。假设有3种属性，继承的方法表示全部可能需要6个子类；装饰器模式只需构建3种装饰就行。

具体形式：首先构建一个抽象类（画形状），然后有两个分支，一个是对于抽象类的实例（画圆，画线），另一个是对抽象类的装饰（红色，虚线，粗线）。
抽象类的实例分支除了实例化抽象类的特征外，还可以添加一些属性，他们继承的是基础抽象类。
装饰分支：首先建立一个装饰的抽象类（特征）继承基础抽象类（画形状），这里会将基础抽象类作为输入，先将他们原有的功能赋值给本类，然后添加装饰属性；对于装饰的抽象类，需要一些子类去继承和实例化，并用不同的装饰属性去覆盖父类的装饰属性。

具体装饰过程：将原有的对象作为形参构建具有新属性的对象，有点像嵌套的感觉，从而达到在原有基础上动态添加新属性的功能

6、代理模式

在代理模式种，一个类代表另一个类的功能。创建一个有现有对象的对象来提供对外的功能接口，实现中介隔离的作用，同时实现开闭原则，增加功能。

应用场景：在某些情况下，直接访问一个对象会出现一些问题，比如买火车票问题里，直接去火车站买可能会出现路途遥远的问题，因此可以增加一个中间层，实现在访问一些类时做一些控制。比如增加车票代售处来解决路途远的问题，同时避免了再建一个火车站。

实现：首先创建一个共有抽象类，比如火车票问题里的售票系统类A，然后创建一个真实类来实例化这个类，比如创建火车站类 a 来实现售票系统功能。然后继承共有类A创建代理类b，再这个类里声明一个真实类a，同时实现要代理的功能函数，比如售票功能，注意再这个功能函数中实现售票功能的方法是直接调用真实类a中的相关功能。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

7、原型模式

原型模式用来创建重复的对象，是一种创建型模式。主要是用于对像的复制，经常与其他模式进行混用。
原型模式主要利用了clone方法，这种方法直接操作内存中的二进制流，相比new一个对象性能要好很多，在复制大的对象时候，性能差距很大。

原型模式主要包括：原型类，实现类。
原型类是实现类的父类，主要包括一个clone方法，在这个方法里调用本地的clone方法，返回一个复制后的对象。
实现类，主要负责实现单独的功能，一般是对复制后对象的个性化更改。

需要注意的是，存在深拷贝和浅拷贝两种，一边拿clone方法是浅拷贝，就是说只对基本的实际类型进行拷贝，而对于数组、容器、引用对象等都只是拷贝指针，也就是说他们都是对一个对象的引用。如果想实现深拷贝，则需要在clone方法中对这些对象单独进行拷贝。

8、模板模式

在抽象类公开定义一个执行他的方法的模板，子类中按需求重写某些方法的实现，但是在最后调用的时候用抽象类中模板的形式进行调用。属于行为型模式

主要解决：有一些方法通用时，在子类中要重新写这些方法，因此可以把这些重复的部分抽象出来放在父类中，把特殊的部分延迟到子类中。

核心就是，把通用的 部分抽象到父类里，把特殊的部分下放到子类中实现，

结构：

抽象一个父类：比如在所有游戏的play问题中，都有一个初始化，开始游戏，操作游戏，结束游戏的流程，把这些流程放到父类的play方法中。
子类继承父类，实现不同的具体的方法：比如足球游戏中，对初始化、开始、进行、结束游戏这四个步骤进行具体的实现，在赛车游戏中，也对这四个过程进行单独的具体的实现。

执行过程中，需要实现一个具体的游戏，比如足球游戏，并对足球游戏中的四个步骤具体实现进行设置，在最后play时只需要调用父类的play方法，就可以完成整个游戏的play过程。

9、外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。
主要是为了简化接口。
方法：在客户端与复杂系统之间加一层，这一层将调用顺序和依赖关系处理好
比如画图任务里：
1、抽象一个画图类，
2、对画图类进行实例化，包括长方形、圆型等，完成具体形状的绘制过程
3、创建一个外观类，在这个类里，编写不同形状的绘制组合的函数。
4、在客户端，只需要直接调用外观类的不同形状组合的函数，便能完成不同组合的图形绘制，而不用关心内部绘制过程

10、建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
主要解决：要创建一个复杂的对象，这个对象有多个固定的部件组成，但是其组合方式经常变化。
解决方法是：将变的与不变的分离开，包括产品类，建造者与导演。

产品类：定义了产品的具体形态。
建造者：负责具体子产品的创建与实例，这部分一般是不变的。
导演：按照需求进行多种组合，这部分是变化的部分。

例子：客厅的不同装修方案：
产品类：客厅，定义了客厅的组成单位，包括电视，沙发，灯具。
抽象建造者：装修工人抽象类，包括创建产品对象和返回产品对象。创建产品是声明了不同的组成单位的建造方法，注意都是纯虚函数。
具体建造者：具体的工人1\2\3，是抽象建造者的具体实例，比如不同的电视类型，沙发类型等。这里如果有部分虚函数没有实例则会报错
指挥者：项目经理，输入建造者。负责不同的组合方案，比如方案一是电视、沙发，方案二是沙发、灯具等

客户端调用时，创建项目经理，输入装修工人，然后调用不同的装修方案，最后呈现装修效果。

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

11、观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

主要是，一个对象的状态改变会通知到其他多个对象，即分为：发布者和观察者两类。主要涉及低耦合和高协同的问题。

高协同：在发布者中创建一个列表，用来存储它要通知到的观察者对象，并通过创建通知函数来更新列表内对象的相关状态。

低耦合：抽象出发布者和观察者两个抽象类，在相关引用函数中使用抽象类名来代替具体对象类名，降低程序的耦合性。
例如：电视和手机作为发布者发布天气情况，老人和小孩作为观察者接受天气情况。
1、抽象发布者：天气发布，包含三个函数：添加观察者对象、减少观察者对象、发布通知调用观察者的更新函数（这里的观察者对象用抽象类，来降低不同对象的耦合性）
2、具体发布者：电视、手机来具体实现这三个函数
3、抽象观察者：状态更新函数，用来更新具体状态
4、具体观察者：老人、小孩，实现具体更新函数。

12、状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。有点像指针类的形式

有些任务需要根据某些条件进行状态转换，并执行对应的动作。简单的方法是利用一连串的判断语句，来判断不同的状态并执行相应的动作，但是有状态调整时，需要对整个判断语句的程序进行修改，

方法：将不同状态及动作抽象出来，然后对不同的状态进行实例化，并且在具体的类中添加状态转移的相关方法，将状态的实例变量值进行改变。

13、适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

程序中有些接口不统一，导致两个类之间不能直接调用。但是更改这两个类的接口又不够现实时，可以通过一个中间桥梁来让两个类可以兼容。

例如：不同国籍的球员交流需要一个翻译，翻译就是适配器
球员类中默认的使用英语战术，但是和中国籍球员有相同意义的战术但是接口不同，方法是继承英语球员类创建翻译类，同时在实现英语战术时候，利用中国籍的战术接口实现。

14、备忘录模式

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。
所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。比如游戏中的存档
具体方法是：通过一个备忘录类来专门存储这些状态。并通过一个备忘录管理类来处理这些状态
例：游戏存档，
1、创建备忘录类，设置保存的状态a、b、c
2、在原生游戏类中创建存档函数，并返回new 设置状态的备忘录实例
在原生游戏类中创建恢复函数，将传入的备忘录实例形参的状态赋值到当前状态
3、创建备忘录管理类，里面来存储备忘录实例

4、在主函数中创建备忘录管理类，在保存和恢复时候调用原生游戏中的存档和恢复函数实现存档和恢复

15、组合模式

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
简单说，组合模式就是用在构建树的过程。它可以自由添加和删除子节点，叶子节点，及子树。
它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

关键：统一树枝与叶子节点的接口，树枝内部组合该接口，并有list来保存这些节点

例：构建 总公司，分公司，部门a，部门b 的结构
1、从树枝和叶子节点中抽象出一个抽象类，component，类中包括add和remove两个纯虚函数
2、继承component类构建部门类，这是叶子节点，由于不能添加子节点，所以这个类中的add和remove函数不具备功能
3、继承component类构建分公司类。这是树枝节点。它可以添加子节点，所以通过list来保存它的子节点，并通过实现add和remove函数来维护这个list

4、在主函数中，利用add和remove来维护这个树。

透明方式和安全方式：
由于树枝节点和叶子节点有无分支的区别，所以树枝节点需要add和remove两个函数，叶子节点不需要add和remove两个函数，那么在抽象类中就有是否声明add和remove函数两种选择
透明方式：在抽象类中声明这两个函数
安全方式：在抽象类中不声明这两个函数

16、迭代模式

需要用一种方法顺序来访问一个聚合对象中的各个元素，又不暴露对象内部的表示，此时需要一个迭代模式。
结构：
1、迭代抽象类，声明first、next、是否结尾、当前对象 等函数
2、聚集抽象类，声明常见迭代器
3、具体迭代类（继承抽象迭代），包含一个私有的聚集类实例，保存它的所有内容。并要实现它的抽象类中的函数
4、具体聚集类（继承抽象聚集），创建一个列表，用来存储聚集集合。

5、主函数中创建聚集类并构建聚集实例，然后利用这个实例构建一个具体迭代实例，然后利用迭代类中的first、next、isdone等实现迭代遍历

17、单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例

核心：构造函数私有化，使得外部不能通过new来创建对象，只暴漏一个接口用来类内创建对象，并通过一个静态变量判断是否已经创建过，避免重复创建

几种形式：

1、懒汉式：第一次调用初始化，避免浪费内存，没有同步锁，多线程不安全

public class Singleton {
private static Singleton instance;
private Singleton (){}

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

}

2、懒汉式（同步锁）：第一次调用初始化，避免浪费内存，必须加锁 synchronized 才能保证单例，但加锁会影响效率。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

3、饿汉式：类加载就初始化，浪费内存，不用加锁就线程安全，效率高
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}

4、双检锁/双重校验锁：第一次调用初始化，避免内存浪费，线程安全
由于只有多线程同时第一次创建时候会出现堵塞，加锁前进行一次判断，就可以避免每次加锁。

public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}

18、桥接模式

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
方法：从多个角度把问题分类分离，并让他们独立，减少耦合。
例：不同手机使用不同软件。
分离两类：手机品牌、软件
1、手机品牌抽象类：包括 抽象函数使用软件
2、软件抽象类：运行软件函数
3、不同手机品牌：继承手机品牌抽象类，包括new软件类
4、不同软件类：继承软件抽象类，实现不同的软件功能

19、命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令
在软件程序中，行为请求者和行为实现者通常式紧耦合的关系，这样对行为记录、撤销等等处理时不方便。因此需要进行解耦。
核心：定义三个角色：（服务员点餐，厨师加工）
1、received：真正接受执行者（厨师）
2、command：分配命令给执行者，不同的命令分配给不同的接收者（不同餐品分配哪个厨师）
3、invoker：使用命令的入口，只需要关心命令就可以。通过调用命令对象的execute来间接调用执行者。关于命令的判断、取消等也在这里实现（服务员，进行添加订单，取消订单，判断是否又餐品等）

20、职责链模式

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

例子：加薪请求，需要一层层往上提交，由于不同领导层职责权限不同，当前领导层权限够时就处理，不够时就向上提交，但是提交者并不用关心后面的逐层提交过程

1、抽象出一个管理层类：必须包括设置当前管理者的上层，声明申请请求函数
2、具体管理层：不同的管理层要根据自己职责重构申请请求函数，当可以解决则解决，不能解决则传递给上层
3、主函数：定义不同管理层，并设置他们的上层，用来职责传递。然后讲请求提交给整个链表的头，链表将自动判断实现或传递，最终完成请求

21、中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

当对象与对象间有大量关联时，一个对象发送改变就需要跟踪与其有关系的对象做相应的处理，导致系统很复杂。
核心：用一个中介对象来处理对象的交互问题，各对象就不用显示的互相引用，达到解耦的效果。比如各国间的通信，通过联合国进行转达，联合过就是中介者。

例子：各国间通信
1、抽象中介者（联合国机构）：声明转达函数
2、抽象对象（国家）：包括他的中介者
3、具体对象（不同国家，如美国、伊拉克等）：声明转达函数并调用中介者的转达函数，实现对其他对象的响应函数
4、具体中介者（联合国安理会）：有一个列表存储它所包括的具体对象，并实现转达函数，在里面调用列表里要转达对象的相关相应函数。

5、主函数：创建一个联合国，创建不同的国家，在联合国列表中添加不同的国家，不同国家进行发言，会自动调用联合国内的程序进行转达。

22、享元模式

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

核心：使用一个哈希表存储已经创建的对象，在新建对象时候，先判断是否已经有这个对象，有则直接返回，没有的时候再创建。

例子：画20个三种颜色的圆
1、抽象形状类：声明绘画方法
2、画圆实体类：定义画圆的属性，半径、位置，颜色等，并具体实现绘画方法
3、创建画圆工厂：包括一个哈希表根据根据颜色存储画圆实例。定义获取实例方法，通过颜色索引哈希表，有则直接返回实例，没有则创建后返回。

4、抓函数：通过画圆工厂获取不同颜色的圆实体，并设置半径、位置后，调用绘画方法进行绘画。

23、解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

例如：乐谱识别，输入时乐谱，程序要根据乐谱规则解释成执行相关的指令
1、抽象解释类：声明方法
2、实现不同的解释方法：对不同的方法进行不同的解释

3、主函数中调用这些解释方法，实现相关的功能

24、访问者模式

在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

解决稳定的结构和异变的数据耦合问题。再被访问的类里添加对外提供接待访客的接口

1、抽象一个被访问者接口，声明accept方法
2、创建被访问实体，实现不同的accept方法
3、定义访问者接口，声明visit方法
4、创建访问者实体，实现不同的visit方法，对传入的被访问者调用不同的方法

5、通过对象结构类来添加、删除访问实体