设计模式

关联：如果类A与类B关联，那么类B被引用为类A的属性；


依赖：如果A类访问B类的属性或方法，或者类A负责实例化类B，那么可以说A依赖B；


聚集：整体与部分的关系，类B是类A的属性，形式同关联关系，但语义不同。
      聚集--部分类的对象不能单独存在，它的生命周期依赖于整体类的对象的声明周期，当整体消失，部分也就随之消失。
      关联--允许每个类的对象都单独存在，例如雇主和雇员的关联关系。


应用场景、优缺点、具体案例
给你一个场景，如果让你来做，你会怎么做


设计模式：
***********************************************************


开闭原则：对扩展开放，对修改关闭，即在不被修改的情况下可以方便扩展。
实现：抽象是关键；


李氏替换原则：任何基类出现的地方，子类一定可以出现；子类具备基类的一切特性。


依赖倒转原则：要依赖抽象，不要依赖实现；


合成/聚合复用原则：要尽量使用合成/聚合，而不是继承来达到实现复用的目的；
原因：父类和子类间有很强的耦合性，不适合变更；


迪米特法则：一个软件实体应当尽可能少的与其他软件实体发生相互作用；
原因：这样将来修改时压力不会传递到相关联的软件实体；


接口隔离原则：为客户端提供尽可能小的单独的接口，而不要提供庞大的总接口。
迪米特法则要求通信的宽度和深度都尽量地小，接口隔离原则要求通信的宽度尽量小；


单一职责原则；将条件转移语句改写成为多态性；


************************************************************


设计模式：优缺点、什么条件下使用


创建型模式：


1、简单工厂模式（静态工厂模式）(over)  一个产品族，一个工厂类
DateFormat.getDateInstance()/DateFormat.getDateInstance(int style)/DateFormat.getDateInstance(int style, Local local);


2、工厂方法模式(over)  把简单工厂的工厂抽象化，一个产品族
collection.iterator();


3、抽象工厂模式(over)  多个产品族的工厂方法模式


4、单例模式(over)
饿汉式、懒汉式、登记式
同步synchronized
Runtime.getRuntime()/Properties的读取；


5、建造者模式(over) vs 策略模式
角色：Director、Builder、CrectBuilder、Product
建造者模式：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示；
            一个产品对应一个具体的builder；


6、原型模式(over) —— 克隆


7、模板方法模式(over)  行为延迟到子系统，组合方式在模板类中。


************************************************************


结构型模式：7


8、适配器模式(over)  多用于改造旧系统


9、组合模式——链表(over) 子节点、叶子节点


10、装饰模式———— 装饰模式，动态地添加行为，而代理模式对访问控制；所以，装饰者中的真实对象是外部传进来的，
      而代理者中的真实对象是在代理类中生成的，所以，装饰者中的真实对象在运行时确定，而代理者中的真实对像在编译时便确定了。
BufferedInputStream

11、代理模式：对其他对象提供一种代理以控制对这个对象的访问，它们有共同的祖先，即继承同一个接口。


12、享元模式(over)  连接池


13、门面模式(over)  常用于集成子系统，定义新的方法，这个方法中调用子系统的方法。

14、桥接模式(over) vs 策略模式/建造者模式，将策略模式的Context抽象化
桥接模式：abstraction、implementor，将它的抽象部分和实现部分分离解藕，使二者可以独立地变化；






************************************************************


行为模式：11


15、策略模式：把算法封装起来，使它可以独立于客户变化；


16、观察者模式(over) Oberver、Obervable、setChanged();


17、迭代器模式(over)  提供一种访问容器中各个对象又不需要暴露容器的内部结构的方法，为容器而生；


18、职责链模式  含有handleRequest的链表，successer、handler、request


19、命令模式(over)  通过command实现行为请求者与行为实现者的低耦合 —— command、Receiver、invoker


20、备忘录模式(over)


21、状态模式(over)  vs  职责链模式


22、访问者模式 node.accept(visitor);


23、解释器模式(over)  正则表达式


24、中介者模式(over)  中介类中关联两个联系对象
优点：联系对象的解耦，且注意力从联系对象转移到了中介身上，便于集中控制。
缺点：由于集中控制，当联系对象多时，中介将变的异常复杂。


************************************************************




关联、依赖、组合、聚合、实现、泛化


依赖：局部变量、方法的参数、静态方法的调用；


关联/聚合：成员变量


*********************************************************************


创建模式
简单工厂模式、工厂方法、抽象工厂模式、原型模式、建造者模式、单例模式；


结构模式
门面模式、代理模式、装饰者模式、适配器模式、组合模式、享元模式、桥接模式；


行为模式
模板模式、观察者模式、策略模式、备忘录模式、职责链模式、命令模式、状态模式、中介者模式、解释器模式、访问者模式；


*********************************************************************


命令模式


命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，
对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能；
命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开委派不同的对象；


请求者发送命令给接收者，接收者执行业务逻辑；所以，业务逻辑是在接收者的行为中定义的；
同过命令角色，实现了请求者与接收者的解耦；


命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，
以及操作是否被执行、何时被执行，以及是怎么被执行的。


命令允许请求的一方和接收请求的一方能够独立演化，从而具有以下的优点：
1、命令模式使新的命令很容易地被加入到系统里；
2、允许接收请求的一方决定是否要否决请求；
3、能较容易地设计一个命令队列；
4、可以容易地实现对请求的undo、redo；
5、在需要的情况下，可以较容易地将命令计入日志；


例子：
client、invoker、receiver、command/concreteCommand


Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
Invoker invoker = new Invoker(command);
invoker.action();
client：玉皇大帝、invoker：太白金星、receiver：孙悟空、command：圣旨；


*********************************************************************


0、门面模式


外部与一个复杂子系统的通信必须通过一个统一的门面对象进行，这就是门面模式；
门面模式要求一个子系统的外部与其内部的通信必须通过一个统一的门面对象进行；


随着业务的发展，设计师往往仍然会发现一个子系统内仍然有太多的类要处理，而是要那个一个子系统的客户端往往只关注一些特定的功能，
需要同时与子系统内部的许多对象打交道后才能达到目的，通过门面模式，可以简化；


优点：
1、为一个复杂子系统提供一个简单的接口；
2、通过门面可以解耦客户端与实现化层；
3、在构建一个层次化的系统时，可以使用门面模式定义系统中每一层的入口，从而简化了层与层之间的依赖关系；


*********************************************************************


1、中介者模式(java与模式)


角色：Meditor、ConcreteMeditor、Colleague、ColleagueA、ColleagueB；
抽象调停者、具体调停者、抽象同事类、具体同事类；
Meditor(+colleagueChanged:void);
ConcreteMeditor(ColleagueA、ColleagueB、+createConcreteMeditor、+colleagueChanged:void);
Colleague(Meditor、+change:void、+action:void);
ColleagueA(+action:void);
ColleagueB(+action:void);
关键字：网状、星形、独立变化；


中介者模式将一个网状的系统结构变成一个以中介者为中心的星形结构。
中介者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以较松散地耦合。
当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保
证这些相互作用可以彼此独立地变化。


中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，
将原本难以理解的网状结构转换成相对简单的星型结构。


中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，
增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。


可以减少子类生成，中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，
这使各个同事类可被重用，无须对同事类进行扩展。


优点：简化了对象间的交互、各同事对象间解耦、减少子类生成（扩展新的中介者子类即可）；


缺点：中介者类会很复杂，难以维护；


例子：


*********************************************************************


2、表达式模式(java与模式)


角色：client、Context、Expression、TerminalExpression、NonTermianlExpression；
客户端、上下文、抽象表达式、终结表达式、非终结表达式；
AbstractExpression(+interpret(Map));
VarExpression(String、+interpret(Map))；
AddExpression(Expression、Expression、+interpret(Map));
Context(Map、String[]、stack);
关键字：语法扩展；


解释器是一个简单的语法解释器，最显著的优点是扩展性，扩展语法，只要增加非终结符类就可以了；
缺点有非终结类膨胀，递归循环影响性能；
尽量不要在重要的模块中使用解释器模式，否则维护会是一个很大的问题。
在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式，弥补Java编译型语言的不足。


优点：
0、语法易于扩展；


缺点：
0、复杂文法难以维护；
1、递归操作，性能差；
例子：client、HashMap、Expression、VarExpression、AddExpression；
加减表达式的实现；


*********************************************************************


3、访问者模式
http://blog.csdn.net/lovelion/article/details/7433591


角色：Visitor、VisitorA、VisitorB、Node、NodeA、NodeB、ObjectStrcture、client；
Visitor(+visite(NodeA)、+visite(NodeB))、Node(+accept(Visitor));
当系统中存在一个较为复杂的对象结构，且不同访问者对其所采取的操作也不相同时，可以考虑使用访问者模式进行设计。


关键字：结构稳定、复杂、不同状态/分类操作、结构和操作解耦、双重分派；


优点：
0、把数据结构和作用于结构上的操作之间的耦合解脱开；
1、增加新的访问操作很方便，直接增加新的访问者即可；
2、将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结果中元素对象
的复用，相同的对象结构可以供多个不同的访问者访问；
3、让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作；
4、双重分派访问递归，树形结构递归；
缺点：
1、增加新的元素类很困难；意味着在抽象访问者角色中增加一个新的抽象操作；
2、破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴漏一些自己的内部操作和内部状态，
否则无法提供访问者访问；
使用场景：
1、一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，
不同类型的对象可以有不同的访问操作；
2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这
些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的
访问操作分离；
3、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作；


例子：男人、女人、成功、失败、恋爱、结婚时的反映；
老师、学生、论文数量、考试成绩等绩效的反映；


*********************************************************************


4、状态模式


角色：context、state、stateA、stateB；
context(state、+request)、state(+handle(context));
当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类；
主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同的一系列类当中，可以把复杂的逻辑判断简单化；


关键字：状态、转换、分支；


优点：将所有与某个状态有关的行为放到一个类中，而不是提供一个巨大的条件语句；


缺点：新增状态要修改状态转换的代码；


例子： Sunny软件公司欲开发一款纸牌游戏软件，在该游戏软件中用户角色具有入门级(Primary)、熟练级(Secondary)、
高手级(Professional)和骨灰级(Final)四种等级，角色的等级与其积分相对应，游戏胜利将增加积分，失败则扣除积分。
入门级具有最基本的游戏功能play() ，熟练级增加了游戏胜利积分加倍功能doubleScore()，高手级在熟练级基础上再增加换牌功能changeCards()，
骨灰级在高手级基础上再增加偷看他人的牌功能peekCards()。
试使用状态模式来设计该系统。
银行帐户管理
*********************************************************************


5、备忘录模式
角色：备忘录(Memento)、发起人(Originator)、负责人(Caretaker)
Memento(state、+get/set)、Originator(state、+createMemento()、+resotoreMemento(Memento))、Caretaker(Memento、+get/set);
备忘录模式意在不破坏封装的情况下，将一个对象的状态捕捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
*********************************************************************


6、命令模式
角色：客户端（Client）、命令（Command）、具体命令（ConcreteCommand）、请求者（Invoker）、接收者（Receiver）;
行为：请求者：action、命令：execute、接收者：action；
Commond(Receiver、+execute())、Receiver(+action())、Invoker(Commond、+action());
命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象；
命令模式通过命令对象把请求的一方和接收命令的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，
更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。
优点：
1)、新的命令很容易被加入到系统里；
2)、允许接收请求的一方决定是否要否决请求；
3)、能较容易地设计一个命令队列；
4)、可以容易地实现对请求的Undo和Redo；
5)、在需要的情况下，可以较容易地将命令记入日志；


*********************************************************************


7、责任链模式


角色：抽象处理者（Handler）、具体处理者（ConcreteHandler）
行为：handleRequest;
Handler(successer、+handleRequest);
*********************************************************************


8、迭代子模式


角色：Iterator（抽象迭代子）、ConcreteIterator（迭代子）、聚集角色（Aggregate）、具体聚集角色（ConcreteAggregate）;
Iterator(ConcreteIterator、+next())、Aggregate(+iterator());
*********************************************************************


9、观察者模式


角色：Subject（抽象主题）、ConcreteSubject（具体主题）、Observer（抽象观察者）、ConcreteObserver（具体观察者）；
Subject(Vector<Observer>、+notify()、+add(Observer)、+remove(Observer)); Observer(+update());
观察者模式可以实现表示层和数据逻辑层的分离；
*********************************************************************


10、模板模式
行为：hookMethod、concreteMethod、abstractMethod
方法的实现延迟到子类
*********************************************************************


11、策略模式
针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以互相替换。策略模式使得算法可以在不影响到客户端的情况下发生变化；
角色：Context、Strategy、ConcreteStrategy;
行为：contextInterface、strategyInterface;
Context(strategy、+operate())、Strategy(+operate());
*********************************************************************


12、桥接模式
将抽象化与实现化脱藕，使得二者可以独立地变化；
角色：抽象化角色（Abstraction）、修正抽象化角色（Refined Abstraction）、实现化角色（Implementor）、具体实现化角色（Concrete Implementor）;
Abstraction(Implementor、+operation())、Implementor(+operationImpl());
*********************************************************************


13、享元模式
共享池
*********************************************************************


14、代理模式


角色：subject、ProxySubject、RealSubject;
subject(+request())、ProxySubject(RealSubject、request()、+preRequest()、+postRequest())、RealSubject(+request());
反射、动态代理；


*********************************************************************


15、装饰模式
装饰者模式使用原来被装饰的类的一个子类的实现，把客户端的调用委派给被装饰类。
装饰模式的关键在于这种扩展是完全透明的。
角色：Component（抽象构件）、ConcreteComponent（具体构件）、Decorator（装饰者模式）、ConcreteDecorator（具体装饰者模式）;
Component(+sampleOperation())、Decorator(Component、+sampleOperation());


*********************************************************************


16、合成模式
角色：Component（抽象节点）、Composite（子节点）、Leaf（叶子节点）
Component(Composite、+sampleOperation())、Composite(Vector<Component>、+sampleOperation()、+add/remove())、Leaf(+sampleOperation());


*********************************************************************


17、适配器模式
角色：Target（目标接口）、Adaptee（源角色）、Adapter（适配器）;


*********************************************************************


18、原型模式
克隆
*********************************************************************


19、建造者模式
角色：Builder（抽象建造者）、ConcreteBuilder（具体建造者）、Director（导演者）、Product（产品）
Builder(+buildPart1()、+buildPart2()、+retrieveResult:product)、Director(Builder、+construct());
将一个产品的内部表象和产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象；
*********************************************************************
20、单例模式
私有化构造方法；
同步；


*********************************************************************


21、抽象工厂模式、工厂方法模式、简单工厂模式;


*********************************************************************