一篇文章学习23种设计模式（Java）

练习的代码已上传到GitHub和gitee，需要的自取。
GitHub：https://github.com/angenin/DesignPattem
gitee：https://gitee.com/angenin/DesignPattem

设计模式的7大设计原则

1. 单一职责原则：降低类的复杂度，一个类只负责一项职责。
2. 接口隔离原则：要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
3. 依赖倒转(倒置)原则：通过要面向接口的编程来降低类间的耦合性，实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。
4. 里氏替换原则：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。
5. 开闭原则（OCP原则）：当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。
6. 迪米特原则（最少知道原则）：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
7. 合成复用原则：要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

设计模式分为三大类

1. 创建型模式（共五种）

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

2. 结构型模式（共七种）

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

3. 行为型模式（共十一种）

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

UML类图

依赖：泛化(继承)、实现、关联（聚合、组合）

依赖（箭头虚线）

泛化（空心三角箭头实线）

泛化关系就是继承。

实现（空心三角箭头虚线）

关联（箭头实线(单向)或实线(双向)）

聚合（空心菱形箭头实线）

定义属性后没new出对象为聚合。

组合（实心菱形箭头实线）

定义属性后new出对象为组合。

IDCard和person是组合关系。
head和person是聚合关系。

即使IDCard定义时没有new出对象，但是定义了 级联删除（删除person时也删除对应的IDCard）后，IDCard就变成了组合关系了。

创建型模式

单例模式（Singleton）

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

单例模式推荐的4种方式：

1. 饿汉式
   可能存在内存资源浪费的问题。
2. 懒汉式（双重检查）
   懒汉式存在线程安全问题。
   在方法上加synchronized虽然线程安全问题，但是性能上会有所下降。
   使用双重检查即解决了线程安全问题，性能有一定的提升。
3. 静态内部类
   Singleton类装载时，内部类不会立即被装载，而是当调用getInstance方法时，内部类才会进行装载（并且只装载一次），而且内部类在装载的时候线程是安全的，所以不会有安全性的问题。
4. 枚举
   能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

工厂方法模式（Factory Method）

工厂模式其实挺简单的，不过韩老师举的例子比较难理解，所以我是根据https://blog.csdn.net/zhangerqing/article/details/8194653这篇文章里工厂模式的例子进行练习的。

简单工厂：


工厂方法模式：

抽象工厂模式（Abstract Factory）

原型模式（Prototype）

原型模式就是去实现Cloneable接口，并重写clone方法。


浅拷贝：只能对象基本类型和string类型进行拷贝，其他类型这是赋值地址值，其他类型的属性一修改，所有的对象都会被影响。（实现Cloneable接口并重写clone方法）

深拷贝：对对象的所有属性进行拷贝，一种是通过重写clone方法，然后在浅拷贝的基础上再对除基本类型和string类型外的其他类型的属性进行单独的调用其属性的clone方法进行拷贝（其他类型的属性也需要实现Cloneable并重写clone方法）；第二种是通过系列化整个对象，然后再反序列化得到全新的对象，从而实现拷贝，对象需要实现Serializable接口，对象的其他类型的属性也需要实现Serializable接口。（实现Serializable接口）

建造者模式（Builder）

建造者模式我也是参照https://blog.csdn.net/zhangerqing/article/details/8194653这篇文章里的例子进行练习的。

结构型模式

适配器模式（Adapter）

类适配器

对象适配器

接口适配器

桥接模式（Bridge）

装饰者模式（Decorator）

组合模式/部分整体模式（Composite）

外观模式/门面模式（Facade）

外观模式(门面模式)和中介者模式的区别：外观模式调用的其他类之间是可以相互关联、依赖调用的，而中介者模式在调用其他类时，其他类之间是不可以有依赖关联的，都是由中介者类统一进行调用的。

享元模式（Flyweight）

代理模式（Proxy）

静态代理

动态代理（JDK代理）

Cglib代理

可以在内存中动态的创建对象，而不需要实现接口

行为型模式

模板方法模式/模板模式（Template Method）

钩子方法

命令模式（Command）

访问者模式（Visitor）

这个模式中重要的是双分派。

迭代器模式（Iterator）

观察者模式（Observer）

中介者模式（Mediator）

外观模式(门面模式)和中介者模式的区别：外观模式调用的其他类之间是可以相互关联、依赖调用的，而中介者模式在调用其他类时，其他类之间是不可以有依赖关联的，都是由中介者类统一进行调用的。

备忘录模式（Memento）

解释器模式（Interpreter）

状态模式（State）

策略模式（Strategy）

责任链模式（Chain of Responsibility）

学习视频（p1-p150）：https://www.bilibili.com/video/BV1G4411c7N4?p=1