设计模式学习---总结

面向对象设计原则 

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

详细介绍：https://blog.csdn.net/lovelion/article/details/7537584

2、里氏代换原则（Liskov Substitution Principle）

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

详细介绍：https://blog.csdn.net/lovelion/article/details/7540445

3、依赖倒置原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

详解介绍：https://blog.csdn.net/lovelion/article/details/7562783

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

详细介绍：https://blog.csdn.net/lovelion/article/details/7562842

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

详细介绍：https://blog.csdn.net/lovelion/article/details/7563445

6、单一职责原则（Single-Responsibility-Principle）

核心：一个类只负责一个功能领域中相应的职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。 

思想：如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。

详细介绍：https://blog.csdn.net/lovelion/article/details/7536542
 

一、设计模式分类

 

设计模式有两种分类方法，即根据模式的目的来分和根据模式的作用的范围来分。

根据目的来分

根据模式是用来完成什么工作来划分，这种方式可分为创建型模式、结构型模式和行为型模式 3 种。

1. 创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF 中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。
2. 结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，GoF 中提供了代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。
3. 行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。GoF 中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

根据作用范围来分

根据模式是主要用于类上还是主要用于对象上来分，这种方式可分为类模式和对象模式两种。

1. 类模式：用于处理类与子类之间的关系，这些关系通过继承来建立，是静态的，在编译时刻便确定下来了。GoF中的工厂方法、（类）适配器、模板方法、解释器属于该模式。
2. 对象模式：用于处理对象之间的关系，这些关系可以通过组合或聚合来实现，在运行时刻是可以变化的，更具动态性。GoF 中除了以上 4 种，其他的都是对象模式。

1.1 创建型的设计模式

• 单例模式(Singleton)
• 构建模式(Builder)
• 原型模式(Prototype)
• 抽象工厂模式(Abstract Factory)
• 工厂方法模式(Factory Method)

1.2 行为设计模式

• 策略模式(Strategy)
• 观察者模式(Observer)
• 模板方法模式(Template Method)
• 状态模式(State)
• 责任链模式(Chain of Responsibility)
• 解释器模式(Interpreter)
• 命令模式(Command)
• 备忘录模式(Memento)
• 迭代器模式(Iterator)
• 访问者模式(Visitor)
• 中介者模式(Mediator)

1.3 结构型设计模式

• 装饰者模式(Decorator)
• 适配器模式(Adapter)
• 代理模式(Proxy)
• 组合模式(Composite)
• 桥连接模式(Bridge)
• 蝇量模式(Flyweight)
• 外观模式(Facade)

二、各种模式的表述
 

简单工厂

Simple Factory，是由一个工厂对象决定创建出哪一种产品类的实例，是工厂模式家族中最简单实用的模式。

工厂方法

Factory Method，定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。为了遵循扩展开放，修改关闭原则，将简单工厂类转换为工厂方法接口，将其Switch分支分离成子类去继承工厂方法接口类，顺利的将创建对象的过程延迟到子类。

抽象工厂

Abstract Factory，提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

原型模式（Prototype）

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

建造者（Builder）

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

单例（Singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点

适配器模式（Adapter）

将一个类的接口转换为客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类一起工作。

代理模式（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

组合模式（Composite）

将对象组合成树形结构以表示“部分——整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。

桥接模式（Bridge）

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

蝇量模式（flyweight）

运用共享技术有效的支持大量细粒度的对象。

外观模式（Facade）

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

装饰模式（Decorator）

动态的给一个对象添加额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

备忘录模式（Memento）

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态

命令模式（Command）

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。

策略模式（Strategy）

它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

模板方法（TemplateMethod）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

观察者（Observer）

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

迭代器（Iterator）

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

职责链（Chain of Responsibility)

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，知道有一个对处理它为止。

中介者(Mediator)

用一个中介者对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的关系

状态(State)

当一个对象内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

访问者（Visitor）

表示一个作用于某对象结构中的个元素的操作。它使你可以在不改变各元素的类的前提下定义作用与这些元素的新操作。

一、简单工厂模式、工厂方法模式、抽象工厂模式之间的区别：（具体看UML）

1、工厂方法和简单工厂：

工厂方法模式和简单工厂模式在结构上的不同很明显。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

　　工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么不妨把抽象工厂类合并到具体工厂类中去。由于只有一个具体工厂类，所以不妨将工厂方法改为静态方法，这时候就得到了简单工厂模式。

2、三者的区别。

简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。
工厂方法模式相当于在简单工厂模式的基础上增加一个抽象工厂，在简单工厂模式下如果增加一个产品，要修改工厂类，不符合开闭原则。在工厂方法下，只需要增加具体工厂和具体产品即可。
抽象工厂，类似于一个集团旗下生产的各种产品的工厂，这些产品是一个产品族。是在工厂方法下的扩展。比如一个产品的界面，可以通过直接改变具体工厂的实例来改变产品的界面风格。

与工厂方法模式不同的是，抽象工厂模式中的具体工厂不再是只能创建一种产品，一个具体的工厂可以创建一个产品族的产品。

 

二、简单工厂模式与策略模式的区别

没理解透彻之前，感觉这两者很像。

策略模式传入不同的实现对象，然后执行相应的不同实现方式。而工厂模式则仅仅是返回了不同的实例对象。

https://blog.csdn.net/cpcpcp123/article/details/107341040

https://blog.csdn.net/lmx125254/article/details/86625960

 

三、装饰模式与适配模式、代理模式的区别

装饰器与适配器、代理都有一个别名叫做 包装模式(Wrapper)。

它们看似都是起到包装一个类或对象的作用，但是使用它们的目的很不一一样。

• 适配器模式：是要将一个接口转变成另一个接口，它的目的是通过改变接口来达到重复使用的目的。 
• 装饰器模式：不是要改变被装饰对象的接口，而是恰恰要保持原有的接口，但是增强原有对象的功能，或者改变原有对象的处理方式而提升性能。所以这两个模式设计的目的是不同的。
• 代理模式：一个类而去调用另一个类的方法，不对这个方法进行直接操作

从定义上看适配器模式是把对象或者功能放到一个新对象中引用。装饰模式是对核心对象或者功能的扩展。代理模式是隔离调用类和被调用类的关系，通过一个代理类去调用。

总的来说就是如下三句话：

 1 适配器模式是将一个类(a)通过某种方式转换成另一个类(b).
 2 装饰模式是在一个原有类(a)的基础之上增加了某些新的功能变成另一个类(b).
 3 代理模式是将一个类(a)转换成具体的操作类(b).

四、动态代理和装饰者设计模式的区别理解

从结构和写法上来讲，两种设计模式非常相似，怎么理解他们的区别呢？

装饰者模式，基本上没有争议，就是为了给装饰者的方法增强，单纯的是为了在装饰者方法上增加其他功能。

动态代理模式也可以在被代理的方法上增加功能，也就是在功能上都可以实现，但是代理设计模式有他的不同，被代理的对象难以直接获得或者是不想暴露给客户端，而装饰者模式是继承的一种替代方案，就是说代理设计模式可以理解为没有办法或者没有权限直接访问被代理对象，所以被代理对象的具体信息也是隐藏的。

而且：

代理模式：对于被代理的对象有控制权，可以执行或者不执行。

装饰着模式：没有控制权，肯定会执行，但是增加了一层装饰的功能。