设计模式思维导图

依赖

子类

1.简单工厂模式

1.享元模式运用共享技术有效的支持大量细粒度的对象，2.享元模式能够解决重复对象的浪费问题，当有大量的相似对象时，需要缓冲池，无需总是创建新对象，而是从缓存池中去取，这样可以降低系统内存，提高效率3.广泛应用于池技术

1.当类的分类变得复杂的时候，我们可以在类中添加一个创建对象的抽象方法，将根据某种条件分类的具体类来实现，生成对应的一批类

接口

类图

1.定义了算法簇（策略组），将他们封装起来，使他们可以相互替换，这样就可以将算法的变化和使用算法的用户独立2.将变化的代码抽离出来，面对的是接口编程，（独立出了策略接口），体现了少用继承，多用聚合的原则

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

concreteAbstraction

ConcreteObserver

1.封装了些作用于某种数据结构的各元素的操作，可以再不改变数据结构的条件下定义新的操作2.作用是为了将数据结构和数据结构的操作分离开来，解决数据结构和操作的耦合问题3.适用于对一个类型的对象执行不同的操作

实现

装饰者模式

被适配的类

Componentadd（）添加节点方法remove（）移除节点方法

继承

ConcreteSubject

外观模式为客户端提供了一个统一的接口，调用者只需要发布命令，而具体子系统的操作交给了外观类调用

深拷贝

1.相当于给目标对象提供了一个替身，来控制对这个对象的访问，即通过代理对象来访问目标对象，可以再不修改源码的情况下，对目标方法进行增强

1.FlyWeight就是抽象的享元角色，定义了对象内部状态和外部状态的接口2.ConcreteFlyWeight是具体的享元角色，实现相关的业务流程3.UnSharedConcreteFlyWeight是不可共享的，一般不会出现在工厂中4.享元工厂类则是里面存了一个池容器（集合），可以从中获取对应的对象

抽象类，在这里充当的是桥的作用

client

client可以使用这个接口

使用

需要保存的对象

构造方法：1.先私有化构造器2.创建一个实例化成员对象（这个对单项是静态的）3.可以直接在成员变量中赋值，也可以在静态代码块中赋值4.给一个方法，可以使静态也可以是普通方法，我们可以这个方法获取这个单实例对象

备忘录对象

代理类聚合了一个目标类，代理类可以再目标类功能的基础上，对其进行增强

ConcreteVisitor

dst类

叶子节点

非终结符表示式

具体实现类1method1（）method2（）method3（）

聚合

director里面有具体的构造方法，决定聚合的builder各个方法如何构造，最后会返回创建的product

proxyFactory

1.解决的是需要在不同的状态之间进行转换，每个状态对外都有不同的行为2.当一个类的状态发生改变，允许改变其行为，就像是改变了类

第二种是利用流，需要本对象，和成员中的引用类型对象都得实现序列化需要的流：ByteArrayOutputStream bos = null;        ObjectOutputStream oos = null;        ByteArrayInputStream bis = null;        ObjectInputStream ois = null;bos = new ByteArrayOutputStream();            oos = new ObjectOutputStream(bos);            oos.writeObject(this);//将这个对象写入内存            bis = new ByteArrayInputStream(bos.toByteArray());            ois = new ObjectInputStream(bis);            sheep = (Sheep) ois.readObject();

会动态的在内存中创建代理对象，InvocationHandler里面利用方法的反射执行目标方法

接口MethodInterceptor

Elementaccept(Visitor visitor)

Commandexecute（）//执行undo（）//撤销

客户端调用具体的实现类的模板方法就可以执行

外部状态是对象得以依赖的一个标记，是随环境而改变的，不可共享的状态

中介者中持有colleague，每个colleague中持有中介者来完成调用

工厂模式

concreteElement

建造者模式

被代理的类

浅拷贝

负责保存对象信息的类

抽象类

外观类

具体实现类2method1（）method2（）method3（）

ConcreteState

具体的实现类

Observerupdate（）//用于更新数据

在聚合的聚合类里面，有着对应的数组或者集合，存在一个返回对应迭代器的方法

concreteBuilder实现上述的构造方法

统一的聚合接口，将客户端和集合解耦

结构性模式

观察者模式是多对一的一中依赖，一的那一方为subject，多的那一方为observersubject会通知observer变化

组合模式

第三类，通过枚举类实现

子系统

饿汉式

ConcreteStrategy

ConcreteHandler

内部状态

1.由于java是单继承机制，那么src类不许被继承，那么dst类就必须是接口，有一定的局限性2.src类的方法会暴露在适配器中，增加了使用成本3.优点是相对灵活

colleagueMediator//持有中介者

strategyA      operation1（）      operation2（）......

单例设计模式

是template方法中定义了抽像方法的执行顺序，具体实现延迟到了子类

CareTakerlist<Memento>//保存多个状态的集合

装饰者模式就是动态的将新的功能添加到对象上，利用的是decorator中聚合的component对象，可以不断的用装饰类在外面相当于包装一层

1.首先是将发送请求的用户与执行请求的对象解耦，发送请求的对象是调用者，只需要调用command的execute方法就可以让receiver执行操作，不必知道receiver具体的执行过程2.但是这样就很容易导致类的膨胀3.空命令也是一个设计模式，我们不用重复的判空

在保证封装性的前提下，捕获一个对象的状态，并在该对象之外保存他的状态，这样以后就能恢复当前的状态

迭代器模式

代理类里面得聚合一个需要代理的对象，编译类型为Object通过Proxy.newProxyInstance（）生成的需要类加载器，类的接口，以及InvocationHandler

原理就是在处理请求的抽象方法中，定义处理的条件，如果不能处理，那么就会调用职责链的下一个对象来处理，可以组成环形队列，这样不管哪个环节进入，最后都可以处理

外部状态

ObjectStructurelist<element>

abstraction抽象的角色类

里面持有context对象，用来从一个状态改变到另一个状态

ConcreteImplementor

Mediatorlist<colleague>//操作对象的集合register（）//注册对象的方法execute（）//根据传入参数执行对应对象的具体操作

模板方法模式

抽象的状态，里面定义了许多操作方法，在不同的状态有不同的实现

concreteAggregate

Adapter适配器类

UnSharedConcreteFlyWeight

SubjectregisterObserver（）//注册观察者removeObserver//移除观察者notifyObserver//通知所有观察者list<Observer>//观察者的集合

strategyB       operation1（）       operation2（）.....

1.命令模式是在我们经常向某些对象发送请求，但是并不知道请求的接受者是谁，也不知道某个具体的操作是哪个2.命令模式是消除请求发送者和请求接受者之间的耦合

终结符表达式，实现与文法中终结符相关的解释操作

Invoker

是环境角色，包含了解释器之外的信息

将接口策略聚合到context中，这样就可以动态的改变一组策略的行为

在上述抽象类中，定义一个方法，他默认不做什么事，可以有默认实现，子类可以看情况是否覆盖他，称为钩子方法

命令模式

1.深拷贝有两种，如果我们仅仅只是通过浅拷贝的方式，只对基本数据类型有效，对引用数据类型无效

Contextstate//许多state

抽象类template（）method1（）method2（）method3（）

类适配器，将src通过适配器

leaf

Request

角色类业务流程的具体实现

ConcreteMediator

里面默认空实现，下面的方法继承这个抽象类就可以选择性的实现方法，不必全部实现

FlyWeight

解释器模式

静态代理虽然能够实现代理功能，对目标方法进行增强，但是代理对象会和目标对象实现一样的接口，会增加很多的代理类，维护难

Visitormethod1（Element e）method2（Element e）

ConcreteFlyWeight

适配器模式，分为三类，类适配器模式，对象适配器，接口适配器

在proxy中得实现他的拦截器方法，在这个拦截器方法里实现增强

TerminalExpression

对象的信息

将目标类聚合到proxy类中，为Object类型

第一种，手动复制引用数据类型，即引用数据的对象也得实现clone接口这种方法的缺点特别明显，即手动设置特别麻烦，当成员变量更改时，更换的代码多

src类

第二类，jdk动态代理

proxy代理类

Context

1.如果我们的集合元素是以不同的形式存在的，比如说数组，list，map等等，如果客户端自己遍历他们的话，得使用多种遍历方式，而且还会暴露元素的内部结构2.而迭代器模式就是提供了遍历元素的统一的接口，只需要调用，而无需知道具体的实现

1.就是为请求创建了一个接受者对象的链2.每一个接受者都包含了对另一个接受者的引用，如果一个接受者不能处理，那么就会交给下一个处理

目标类（被代理类）

懒汉式

HandlerHandler handler //职责链下一个对象processRequest（）//处理请求的抽象方法

director的作用是1.隔绝了客户端调用具体的生产过程2.负责产品的生产功能

Client

第一类双重检查法1.先私有化构造器2.创建成员变量，但不给赋值，实现懒加载，需要的时候再加载3.在获取这个对象方法的时候，我们会判断这个对象是否为空，如果为空的话，我们就给他new一个对象，但是因为得实现同步，所以在里面再加上一个synchronize同步代码块，在判断一次是否为空，来实现同步

implementor，动作的抽象类

里面给了添加和删除操作集合的方法，同时还有遍历方法，我们只需要遍历list就行

改进

Receiver      action（）//一些操作方法

Originatorstate//状态信息getMemento（）Memento//返回一个备忘录对象readMemento（）//读取备忘录对象，恢复状态

中介者模式

component类，主体类

ContextStrategyA strategy1StrategyB strategy2//里面聚合了一系列的策略

代理模式

interface接口，里面存在很多方法

第一类，静态代理

第二类，通过静态内部类实现同步1.即在类中定义一个内部内，利用的是jvm的类加载的同步机制，实现同步2.我们在方法中就可以通过直接返回这个静态内部类中的对象即可

1.抽象工厂模式则是抽取出了一层抽象工厂层层，将具体的某种工厂来实现这个接口，就可以批量创建某种类

一些方法

职责链模式

Invoker里面聚合了Command的集合，在里面通过ConcreteCommand来进行相应的操作

Builder修建方法1修建方法2修建方法3修建方法4一个得到结果的方法

策略模式

是指给定一个语言（表达式），定义一种他的文法的一种表示，并定义一种解释器来解释语言中的句子（表达式）

接口适配器

Decorator在修饰类中聚合一个component类

composite非叶子节点中聚合了一个component的list

将实现与抽像分别放在两个不同的层次中，使这两个层次可以单独改变，当我们增加行为或者增加抽象的角色类的时候不会互相干扰，可以避免类过多

ConcreteCommand

product

ConcreteColleague

AggregatecreateIterator（）

ConcreteIterator

1.对于静态代理和jdk动态代理，被代理的目标对象都得实现一个接口，而cglib动态代理则不需要被代理的对象实现接口2.cglib动态代理，又叫做子类代理，他是在内存中创建了一个代理类的子类实现对目标对象功能的扩展

对象适配器

3.抽象工厂模式

Stateoperation1（）;operation2（）;Context对象

非叶子节点

代理对象不需要实现接口，但是目标对象需要实现接口，由于使用的是jdk中的api，所以叫jdk动态代理，代理对象是动态在内存中生成的

1.在一个抽象类中公开定义了一个模板方法，它的子类可以按需要重写方法实现，但调用应该以抽象类中模板方法执行2.实际上就是在抽象类中定义了操作中的一些算法骨架，而将一些类的具体实现过程延后到了子类，使得子类不会干扰算法的框架，只会更改具体的实现

外观模式

IteratorhasNext（） booleannext() Eremove（）void

组合模式创建了对象组的树形结构，component作为抽象父类，里面有添加节点的方法和移除节点的方法，子类有叶子节点（leaf）和非叶子节点（composite），非叶子节点中存在了一个储存子节点的集合

迭代器接口

AbstractExpressioninterpret（）//解释

1.要实现浅拷贝的类，得实现cloneable的接口2.重写clone这个方法3.然后我们需要调用super.clone复制对象后返回

抽象类中多了个钩子方法

Mementostate//状态

享元模式

FlyweightFactory里面聚合了Flyweight的map

NoTerminalExpression

备忘录模式

优缺点分析

代理类

在内存中动态生成被代理类的子类//1.创建一个工具类        Enhancer enhancer = new Enhancer();        //2.设置父类        enhancer.setSuperclass(obj.getClass());        //3.设置回调函数        enhancer.setCallback(this);        return enhancer.create();

客户端只管在使用的时候传入一个对应的策略，那么具体的行为就会改变

Proxy代理类

定义一个接口或者父类，被代理的对象或者父类一起实现相同的父类或者接口

访问者模式

客户端调用聚合类获得迭代器即可遍历

2.工厂方法模式

1.定义了一个工厂类，专门负责根据具体的业务流程创建相应的对象2.当我们需要大量的处理某个类，

桥接模式

状态模式

......

抽象类，适配器

ConcreteComponent

class

执行会调用中介者中的操作方法，根据参数操作具体的对象，调用都通过了中介者

什么是双分派？

原理类图

对象适配器是在类适配器的基础上做了改进，将被适配的类聚合到了适配器中

第三种 cglib动态代理

观察者模式

这些修建方法是构造product的各个部件

使用一个中介对象来封装一系列的对象交互，中介者使各个对象不需要显式的相互引用，利于解耦

抽象表达式，声明了一个抽象的解释操作，其中所有节点共享

动态的将新功能附加到对象上，就像是打包一个快递，不断的将装饰类添加到外层

环境角色，里面维护了许多状态角色

composite

里面有一系列的具体行为

内部状态指的是对象共享出来的信息，储存在享元对象的内部且不会随环境的改变而改变