23种设计模式

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

         设计模式按目的分为三大类：创建型模式、结构型模式、行为型模式。

         创建型模式有：抽象工厂模式、建造者模式、工厂方法模式、原型模式、单例模式。

         结构型模式有：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式。

         行为型模式有：解释器模式、模板方法模式、职责链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、策略模式、访问者模式。

 　　工厂方法模式：将工厂和产品都抽象出来，对外提供统一的接口，具体工厂和产品分别继承对应的父类或实现相应的接口。将具体产品的实例化过程推后，通过工厂子类来决定实例化哪一种具体的产品。一个工厂只有一种产品，只能实例化一个产品对象。

　　模式的角色有：Product（抽象产品）、ConcreteProduct（具体产品）、Factory（抽象工厂）、ConcreteFactory（具体工厂）

　　抽象工厂模式：该模式是对工厂方法模式的扩充。依旧是将工厂和产品都抽象出来，对外提供统一的接口，具体的工厂的产品分别继承或实现相应的父类或接口，不同之处是，该模式中，一个工厂中有多个产品，可以实例化多个产品。实例化的过程依旧是在子工厂中实现的。一个工厂有多种产品，实例化对个产品对象。

　　模式的角色有：AbstractProduct（抽象产品）、ConcreteProduct（具体产品）、

AbstractFactory（抽象工厂）、ConcreteFactory（具体工厂）

　　建造者模式：一个复杂的对象（产品）由多个模块组成，每个模块有多种实现的方式。该模式就提供了一个统一的抽象的实现父类（抽象建造者），该父类只提供模块的抽象方法，具体的实现子类（具体建造者）就继承该类并用自己的方式实现父类中的方法，然后再由一个指挥者来指定采取哪种组合的方式。

     模式的角色有：Builder（抽象建造者）、ConcreteBuilder（具体建造者）、

Product（产品角色）、Director（指挥者）

         原型模式：就是克隆自己，实现的方式，提供一个抽象父类，父类中提供一个克隆方法，子类继承父类，并实现父类中的克隆方法。在使用过程中，直接调用子类中的克隆方法，就能返回一个具体的子类对象。

         模式的角色有：Prototype（抽象原型类）、ConcretePrototype（具体原型类）、

Client（客户类）

         单例模式：一个类将自己的构造方法定义为私有的，并在构造方法中实例化自己，另有一个方法GetXXX()，对外提供访问自己对象的方法。确保整个系统中只有一个该类的实例，并能为整个系统提供服务。

         模式的角色有：Singleton（单例角色）

         适配器模式：该模式主要就是提供一种转换的方式，将一个接口转换成另一个接口，使得原本不兼容的能一起工作。

         模式的角色有：Target（目标抽象类）、Adapter（适配器类）、Adaptee（适配者类）、

Client（客户端类）

         桥接模式：一个具体的对象有两个维度，分别定义每个维度的抽象方法，并在一个维度的抽象类（Abstract）中将另一个维度的抽象类（Implementor）作为其的一个成员变量，在该类的具体实现方法（RefinedAbstract）中就可以调用另一个类的具体实现方法（ConcreteImplementor），用关联关系替代继承关系。

         模式的角色有：Abstraction（抽象类）、RefinedAbstract（扩充抽象类）、

Implementor（实现类接口）、ConcreteImplementor（具体实现类）

         组合模式：将多个对象组合在一起，然后用树形结构来表示整体与部分的关系。提供一个抽象的公共父类（Component），该父类有两个子类，一个类（Leaf）只实现父类中的操作方法（Operation），另一个类（Composite）则实现全部的方法。

         模式的角色有：Component（抽象构件）、Leaf（叶子构件）、Composite（容器构件）

         装饰模式：为一个类增加功能。两个类（ConcreteComponent与Decorator）是同一个类（Component）的子类，然后一个抽象子类（Decorator）又将另一个子类（ConcreteComponent）作为自己的成员变量，然后通过该抽象类的子类（ConcreteDecorator）实现对类功能的添加。

         模式的角色有：Component（抽象构件）、ConcreteComponent（具体构件）、

Decorator（抽象装饰类）、ConcreteDecorator（具体装饰类）

         外观模式：将一个系统中的各种方法（SubSystem）统一封装到一个类（Facade）中，然后外界与系统的交互都通过此类的实现。

         模式的角色有：Fa?ade（外观角色）、SubSytem（子系统角色）

         享元模式：利用共享技术，将一些细小的对象重复使用，不占用过多的资源。

         模式的角色有：Flyweight（抽象享元类）、ConcreteFlyweight（具体享元类）、

UnsharedConcreteFlyweight（非共享具体享元类）、Flyweightfactory（享元工厂类）

         代理模式：两个类之间不直接交互，而是通过代理的交互。

         模式的角色有：Subject（抽象主题角色）、Proxy（代理主题角色）、

RealSubject（真是主题角色）

         职责链模式：将多个能够响应某一请求的类，从低到高串成一条链，然后将请求沿着这条链传递，直到某一个类作出响应为止。

         模式的角色有：Handle（抽象处理者）、ConcreteHandler（具体处理者）、Client（客户类）

         命令模式：将一个请求的实现、发起、响应的过程分别封装，降低了系统之间的耦合度。

         模式的角色有：Command（抽象命令类）、ConcreteCommand（具体命令类）、

Invoker（调用者）、Receiver（接受者）、Client（客户类）

         解释器模式：定义语言的文法，并且建立一个解释器来解释该语言中的句子。

         模式中的角色有：AbstractExpression（抽象表达式）、TerminalExpression（终结符表达式）、

NonterminaExpression（非终结符表达式）、Context（环境类）、Client（客户类）

         迭代器模式：将聚合对象分为两个部分：存储内部数据、遍历内部数据，该模式就是通过遍历的类来访问数据，这样不需要知道内部数据的表示情况。

         模式的角色有：Iterator（抽象迭代器）、ConcreteIterator（具体迭代器）、

Aggregate（抽象聚合类）、ConcreteAggregate（具体聚合类）

         中介者模式：对象与对象之间的交互不直接进行，而是通过中介者来实现交互。中介者将对象之间的交互抽取出来，大大减少对象间的关系数量。

         模式的角色有：Mediator（抽象中介者）、ConcreteMediator（具体终结者）、

Colleague（抽象同事类）、ConcreteColleague（具体同事类）

         备忘录模式：在不破坏封装的前提下，将一个对象完整地保存在另一个对象中，并在需要还原的时候能够恢复到原先的状态。

         模式中的角色有：Originator（原发器）、Memento（备忘录）、Caretaker（负责人）

         观察者模式：多个对象依赖于一个目标对象，当该目标对象发生改变时，多个对象也会随之发生改变。

         模式的角色有：Subject（目标）、ConcreteSubject（具体目标）、Observer（观察者）、

ConcreteObserver（具体观察者）

         状态模式：当对象的状态改变后，对象的行为也随之改变，就像改变了类一样。在类的定义中添加一个状态，对应不同的状态，类中的方法有不同的响应。

         模式的角色有：Context（环境类）、State（抽象状态类）、ConcreteState（具体状态类）

         策略模式：实现目的的方法有多种，将每一种方法封装成一个类，它们继承同一个父类，在需要时可以相互替换。

         模式的角色有：Context（环境类）、Strategy（抽象策略类）、ConcreteStrategy（具体策略类）

         模板方法模式：父类中定义了某一事件的具体操作步骤，并实现了部分或全部的方法，但在子类中，可以重定义父类中的方法，使之表达出不同的意思。

         模式的角色有：AbstractClass（抽象类）、ConcreteClass（具体子类）

         访问者模式：将一个对象中的每一个元素抽取出来，单独的作为一个类，并继承一个公共的父类，然后定义一个抽象的操作，提供对每一个元素的操作方法，在子类中实现具体的操作方法，这样就能在不改变元素类的前提下，通过添加新的操作方法子类实现对元素的新的操作。

         模式的角色有：Vistor（抽象访问者）、ConcreteVistor（具体访问者）、Element（抽象元素）、ConcreteElement（具体元素）、ObjectStructure（对象结构）

软件体系架构课后作业05