设计模式-全网唯一精图

Clien调用主类

Interface3Impl接口3实现类

+ method3()

Observer观察者接口

+ response() : void

10.模板方法模式（Template Method）：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。解释：封装不可变，拓展可变。

实现

BeforeAdvice前置切面接口

聚合

AdvisorAdapter目标接口

+ supportsAdvice（Advice advice）：boolean+ getInterceptor(Advisor advisor)：MethodInterceptor

依赖

Caretaker管理者

- memento : Memento

+ Memento(String state) : void+ setMemento(Memento m) : Memento+ getMemento(): Memento

Flyweight享元接口

+operation(UnsharedConcreteFlyweight ucf):void

Leaf树叶构建

- name:String

+ Leaf(String name)+ operation():void

ObjectStructure对象结构

- list：List<Element>

+ accept(Visitor v) : void+ add(Element e) : String+ remove(Element e) : String

Command命令接口

+ excute() 执行命令+ undo() 撤销命令

client代码示例： // builder做入参构建管理者，调用construct()按照规范步骤设置产品属性。 Product product=new Director(new ConcreteBuilder()).construct(参数1，参数2...);// 获取产品Product product = builder.build();

client代码示例：// 具体目标类Subject subject = new ConcreteSubject();// 具体观察者1Observer obs1 = new ConcreteObserver1();// 具体观察者2Observer obs2 = new ConcreteObserver2();// 目标类添加2个观察者subject.add(obs1);subject.add(obs2);// 通知观察者（内部遍历观察者，执行esponse方法）subject.notifyObserver();

ReceiverA实现者（接收者）

-receiver:ReceiverA

+ action()

public void call() {        command.execute();    }

Subject主题抽象类/接口

+request():void

Interface1接口1

+ method1()

1.适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

1.创建型模式

client代码示例： // 调用static修饰的共有方法：getInstance()获取单例对象 Singleton singleton = Singleton.getInstance();

FlyweightFactory享元工厂

+ getFlyweight(String key) : Flyweight

继承

Adapter适配器

- adaptee:Adaptee适配者

+ Adapter(Adaptee) 使用适配者入参构造+ new()

ConcreteVisitor1具体访问者1

+ visit(ConcreteElementA e) : void+ visit(ConcreteElementB e) : void

ReceiverB实现者（接收者）

-receiver:ReceiverB

ConcreteFlyweight2具体享元2

- key:String

+ ConcreteFlyweight2(String key)+ operation(UnsharedConcreteFlyweight ucf)

ConcreteComponent具体构建

+ operation()

6.享元模式：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。解释：内部状态：我们在享元对象内部定义的成员，不会因为外部环境的改变而改变，内部状态只做对象功能的定义。内部状态是被共享的状态。外部状态：随着外部环境的改变而改变，我们需要使用共享状态来实现不同的功能效果，这个不被共享的状态就是外部状态

client代码示例：span class=\"hl-comment\

Product1Factory 具体工厂1

+ newProductA():ProductA1+ newProductB():ProductB1

ConcreteElementB具体元素B

+ accept(Visitor v) : void+ operationB() : String

ConcreteImplementorB具体实现化类B

+ operationImpl()

Invoker调用者（请求者）

- command : Command

+ setCommand(Command conmand):void+ call()发起请求

MethodBeforeAdviceAdapter方法前置切面适配器

+ supportsAdvice（Advice advice）：boolean+ getInterceptor(Advisor advisor)：MethodInterceptor

ConcreteMediator具体中介者

-colleagues: Lis<Colleague>

+ register(Colleague c) : void 注册+ relay(Colleague c) : void 转发

Iterator迭代器接口

+ first() : Object 第一个+ next() : Object 下一个+ hasNext() : boolean 是否有下一个

ConcretePrototype2具体原型2

+ clone():ConcretePrototype2

Facade外观接口

+ operation()+ method1()

自关联

1.责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。解释：只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。

责任链模式的本质是解耦请求与处理：1.请求发起者不知道最终哪个处理者会执行；2.节点处理者组成了链式结构，允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。

ConcreteColleague2具体同事2

+ send() : void+ receive() : void

<<Interface>>Cloneable原型接口

没有定义克隆方法

ConcreteCommand2具体命令2

+ excute() 执行命令+ undo() 撤销命令

ConcreteObserver1具体观察者1

+ response() : void

9.策略模式（Strategy）：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。解释：它通过对算法进行封装，把算法的使用和实现分割开来，并委派给不同的对象对这些算法进行管理。

Strategy策略接口

+ strategyMethod( ) : void

ConcreteStrategyA具体策略A

+ strategyMethod( ) : void

<<Interface>>AbstractFactory抽象工厂

+ newProductA():ProductA+ newProductB():ProductB

Target目标接口

+ new()

client代码示例：//具体构建Component p = new ConcreteComponent();//具体装饰器（具体构建对象做入参）Component d = new ConcreteDecorator1(p);//执行拓展方法d.operation();d.function1();

<<Interface>>ProductB 产品B接口

+ showName()

Handler抽象处理者接口

- next:Handler下一个处理者

+ setNextHandler(Handler h):+ getNextHandler():Handler+ handleRequest(String request)

Component抽象构建（接口/抽象类）

+ operation():void

Interface2Impl接口2实现类

+ method2()

public void accept(Visitor visitor) {     Iterator<Element> i = list.iterator();     while (i.hasNext()) {          ((Element) i.next()).accept(visitor);     } }

ConcreteBuilder具体建造者

- product:Product

+ buildPart()+ build():Product

Product1 产品1

client代码示例：//创建环境Context context = new Context();//状态Acontext.setState(new ConcreteStateA());//执行handle内部执行：state.Handle(this);context.Handle();//状态Bcontext.setState(new ConcreteStateB());//执行handle内部执行：state.Handle(this);context.Handle();

client代码示例：     // 构造上下文Context context = new Context();// 执行解释context.operation(String info); 内部针对终结符表达式、非终结符表达式执行不同解释。

SimpleFactory简单工厂

+ newProduct():Product

Builder抽象建造者

- product:Product

+ buildPart()+ build():Product

client代码示例：//享元工厂FlyweightFactory factory = new FlyweightFactory();//第1次获取，不存在，创建享元对象并添加进工厂Flyweight f1 = factory.getFlyweight(\"a\");//具体享元执行接口方法，入参是一个非享元对象f1.operation(new UnsharedConcreteFlyweight(\"test1\"));//第2次获取，存在直接返回、具体享元执行接口方法factory.getFlyweight(\"a\").operation(new UnsharedConcreteFlyweight(\"test2\"));;

泛化（继承）

AbstractExpression抽象表达式接口

+ interpret(String info):Object 解释

Component容器接口

client代码示例：  // 具体中介者  Mediator md = new ConcreteMediator();// 定义2个同事Colleague  c1 = new ConcreteColleague1();Colleague  c2 = new ConcreteColleague2();// 都注册到中介md.register(c1);md.register(c2);// 同事c1发消息，内部由md.relay()转发给非本人其他同事的receive()c1.send();   // 同事c2发消息，内部由md.relay()转发给非本人其他同事的receive()c2.send();

7.代理模式：为其他对象提供一种代理以控制对这个对象的访问。解释：在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。

8.状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。解释：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

ProductA1 产品A-1

Abstraction抽象化角色

- implementor:Implementor

# abstraction(Implementor impl)+ operation()

Memento备忘录

-state : String

+ Memento(String state) : void+ setState(String s) : void+ getState() : String

ProductB1 产品B-1

client代码示例：//白色  Color就是Implementor接口、White白色就是一个实现类Color white = new White()；//正方形 Square正方形就是拓展的抽象化子类（继承自抽象类Shape形状，抽象方法draw() ）Shape square = new Square();        //白色的正方形span class=\"hl-code\

Decorator装饰器

- component : Component

+ Decorator(Component component)+ operation():void

类

+ attribute1:type = defaultValue+ attribute2:type-  attribute3:type

+ operation1(params):returnType-  operation2(params)-  operation3()

RefinedAbstraction拓展抽象化角色

6.建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

1.类适配器

5.原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。

Product2 产品2

Visitor访问者接口

+ visit(ConcreteElementA e) : void+ visit(ConcreteElementB e) : void

Context环境类（上下文）

-exp1:AbstractExpression

+ Context()+ operation(String info):void 解释

Proxy代理类

-realSubject:RealSubject

+ request():void增强方法

ConcreteFlyweight1具体享元1

- key:String

+ ConcreteFlyweight1(String key)+ operation(UnsharedConcreteFlyweight ucf)

ConcreteClassA具体子类A

+ abstrasctMethod() : void子类实现+ abstractMethod2()：void

11.访问者模式（Visitor）：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。解释：它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。

Singleton

- instance: Singleton单例对象

- Singleton() 空参构造+ getInstance():Singleton获取单例对象

<<Interface>>ProductA 产品A接口

<<Interface>>Product产品接口

3.组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。解释：组合模式分为透明式（树枝特有方法在抽象类中体现，树叶类复写空实现，客户端使用时无需区分树枝还是树叶）和安全式（树枝特有方法在树枝类中体现）。当节点具有一致行为时采用透明式，当各节点行为不一致较多或树枝节点较为健壮时采用安全式。

public void execute() {        receiver.action();    }

Adaptee适配者

+ old()

4.单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

2.简单工厂模式（Static Factory Method Pattern）：定义一个工厂类，使用static方法创建对象。根据不同参数返回不同实例，每增加一个对象需要修改工厂类，违背了“开闭原则”。

ConcretePrototype1具体原型1

+ clone():ConcretePrototype1

1.工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。使一个类的实例化延迟到其子类。

Concretelterator具体迭代器

-list : Lis<Object>

+ Concretelterator(Lis<Object> list)+ first() : Object 第一个+ next() : Object 下一个+ hasNext() : boolean 是否有下一个

Subject抽象目标类

# observers : List<Observer>

+ add(Observer o) : void+ remove(Observer o) : void+ notifyObserver() : void

ConcreteStateB具体状态B

+ handle(Context c) : void

client代码示例：// 构建发起人  Originator or = new Originator();//构建管理者Caretaker cr = new Caretaker();//发起人状态设置1or.setState(\"1\");//管理者设置备忘录（状态1）cr.setMemento(or.createMemento()); //发起人状态设置0or.setState(\"0\");//恢复发起人备忘录（从管理者）or.restoreMemento(cr.getMemento());  

ConcreteColleague1具体同事1

Spring AOP中的：适配器模式+拦截器模式（非GOF）

-state : State 状态对象

+ Context()+ getState() : State+ setState(State state) : void+ handle() : void

4.装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责。就扩展功能而言， 它比生成子类方式更为灵活。解释：

new(){     adaptee.old();  调用成员类方法。}clent样例：Adapter adapter = new Adapter(new Adaptee);adapter.new();

方法

3.抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

new(){     old();  直接调用父类方法。}clent样例：Adapter adapter = new Adapter();adapter.new();

拦截器核心方法：Object invoke(MethodInvocation mi){      this.advice.font color=\"#e74f4c\

ConcreteStateA具体状态A

Nonterminal Expression非终结符表达式

-exp1:AbstractExpression-exp2:AbstractExpression

+ interpret(String info):Object 解释

UnsharedConcreteFlyweight非享元

- outState : String

+ get() : String+ set() : void

Product2Factory 具体工厂2

+ newProductA():ProductA2+ newProductB():ProductB2

ConcreteAggregate具体聚合

+ add() : Object 添加+ remove() : Object 删除+ getIterator() : Iterator

5.中介模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。解释：将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展

7.观察者模式（Observer）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都得到通知并被自动更新。解释：

    //模板方法    public void TemplateMethod() {        SpecificMethod();        abstractMethod1();        abstractMethod2();    }

Advice切面接口

RealSubject真实主题类

+ request():void

属性

2.对象适配器

3.解释器模式（Interpreter）：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。解释：

client代码示例：     Invoker请求者->ConcreteCommand1命令1->ReceiverA接收者A// 构造命令1Command cmd = new ConcreteCommand1();// 构造请求者Invoker invoker = new Invoker(cmd);// 请求者发起请求（call->command.execute()->receiver.action()）ir.call(); 

client代码示例： // 具体原型对象实现Prototype接口，复写clone().调用时，使用具体原型对象调用clone()创建新的浅克隆对象。 ConcretePrototype1 concretePrototype1= new ConcretePrototype1().clone();

ConcreteSubject具体目标类

+ notifyObserver() : void

关联

ConcreteHandler2具体处理者2

+ handleRequest(String request)

ConcreteClassB具体子类B

+ strategyMethod( ) : void子类实现+ abstractMethod2()：void

ProductB2 产品B-2

ConcreteHandler1具体处理者1

client代码示例：// 2个树枝Component c1 = new Composite();Component c2 = new Composite();// 3个叶子Component leaf1 = new Leaf(\"1\");Component leaf2 = new Leaf(\"2\");Component leaf3 = new Leaf(\"3\");// 树枝1下挂叶子1c1.add(leaf1);// 树枝1下挂树枝2c1.add(c2);// 树枝2下挂叶子2、3c2.add(leaf2);c2.add(leaf3);// 树枝1执行操作c1.operation();

Aggregate抽象聚合

+ add() : Object 添加+ remove() : Object 删除+ getIterator() : Iterator

-strategy: Strategy 策略对象

+ getState() : State+ setState(State state) : void+ strategyMethod( ) : void

6.备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。解释：该模式又叫快照模式。

Mediator中介者接口

+ register(Colleague c) : void 注册+ relay(Colleague c) : void 转发

ConcreteObserver2具体观察者2

Product产品

+ setName(String):void

类名

适配器核心方法：MethodInterceptor getInterceptor(Advisor advisor){      MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();      return new MethodBeforeAdviceInterceptor(advice);结合拦截器模式最终实现拦截器的适配}

AbstractClass抽象类/抽象模板

+ templateMethod() : void+ abstractMethod1() : void+ abstractMethod2()：void+ SpecificMethod() : void

MethodBeforeAdvice方法前置切面（适配者-接口）

+ before（）

注意：Component可以接口/抽象类，本图示例接口的情况。1）实现类 impl 接口2）子类 extends 抽象类（复写抽象方法）

2.结构型模式

client代码示例：//装饰器实现类Facade facade = new FacadeImpl();//执行Interface1接口1的方法1facade.method1();//执行聚合方法（内部可能封装了method2、method3）facade.operation();

client代码示例：// 定义对象结构，并添加具体元素A、BObjectStructure os = new ObjectStructure();os.add(new ConcreteElementA());os.add(new ConcreteElementB());// 构建具体访问者1Visitor visitor1 = new ConcreteVisitor1();// 结构对象接受访问者1->遍历每个元素，执行元素的接受访问者1，实际是访问者访问元素：visitor1.visit(this)->element.operationA()/operationB()os.accept(visitor1);

<<Interface>>Prototype原型接口

+ clone():Prototype

ProductA2 产品A-2

Director指挥者

- builder:Builder建造者属性

+ Director(Builder)构造方法+ construct():Product 建造产品

client代码示例：//组装责任链Handler handler1 = new ConcreteHandler1();Handler handler2 = new ConcreteHandler2();// 先设置下一处理者handler1.setNext(handler2);// 提交请求handler1.handleRequest(\"2\");

public void operation(){ for(Component c : children){    c.operation; }}

Terminal Expression终结符表达式

ConcreteImplementorA具体实现化类A

ConcreteDecorator2具体装饰器2

+ operation():void+ function2()

client代码示例：    // 定义一个字符串聚合 Aggregate ag = new ConcreteAggregate();// 往聚合中添加字符串对象ag.add(\"aaa\");ag.add(\"bbb\");// 获取迭代器       Iterator it = ag.getIterator();// 用迭代器迭代下一个对象while (it.hasNext()) {     Object ob = it.next();}

2.命令模式（Command）：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。解释：请求和执行通过命令沟通，实现了解耦。

2.桥接模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。解释：脱耦就是将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联，将两个角色之间的继承关系改为关联关系。

Implementor实现化接口

Advisor接口

+ getAdvice()：Advice获取切面

ConcreteElementA具体元素A

+ accept(Visitor v) : void+ operationA() : String

State状态接口

+ handle(Context c) : void

5.Facade（外观模式）：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高级接口，这个接口使得这一子系统更加容易使用。解释：隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。它向现有的系统添加一个接口，来隐藏系统的复杂性。这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

Interface3接口3

+ method3()

ConcreteCommand1具体命令1

ConcreteDecorator1具体装饰器1

+ operation():void+ function1()

Element元素接口

+ accept(Visitor v) : void

Interface1Impl接口1实现类

+ newProduct():Product1

3.行为型模式

Composite树枝构建

- children:ArrayList<Component>

+ add(Component c)+ remove(Component c)+ getChild(int i):Component+ operation():void

ConcreteVisitor2具体访问者2

ConcreteStrategyB具体策略B

client代码示例：//创建环境Context c = new Context();//策略Ac.setStrategy(new ConcreteStrategyA(););//执行策略方法c.strategyMethod();//策略Bc.setStrategy(new ConcreteStrategyB(););//执行策略方法c.strategyMethod();

FacadeImpl实现类

- Interface1 interface1- Interface2 interface2- Interface3 interface3

+ operation()+ method1()

Interface2接口2

+ method2()

client代码示例：//具体子类AAbstractClass tm = new ConcreteClassA();//子类执行模板方法tm.TemplateMethod();

MethodBeforeAdviceInterceptor方法前置切面拦截器

- MethodBeforeAdvice advice适配者

+ MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice)适配者入参构造+ invoke(MethodInvocation mi)：Object

MethodInterceptor方法拦截器接口

+ invoke(MethodInvocation invocation)：Object

4.迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。解释：

+ newProduct():Product2

Colleague同事接口

- mediator : Mediator

+ setMediator(Mediator m) : void+ send() : void+ receive() : void

Originator发起人

-state : String

+ setState(String s) : void + getState() : String+ createMemento() : Memento快照+ getMemento(): Memento