目录
1.1.2 抽象工厂（AbstractFactory）...6
1.3.1 责任链模式（Chainof Responsibility）...40
1. 设计模式
1.1创建型模式
FactoryMethod ( 工厂方法 )
AbstractFactory ( 抽象工厂 )
Singleton ( 单态模式 )
Builder ( 建造者模式 )
Prototype ( 原型模式 )
1.1.1工厂方法（FactoryMethod）
定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
适用性
1.当一个类不知道它所必须创建的对象的类的时候。
2.当一个类希望由它的子类来指定它所创建的对象的时候。
3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者
1.Product
定义工厂方法所创建的对象的接口。
2.ConcreteProduct
实现Product接口。
3.Creator
声明工厂方法，该方法返回一个Product类型的对象*
Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
可以调用工厂方法以创建一个Product对象。
4.ConcreteCreator
重定义工厂方法以返回一个ConcreteProduct实例。
例子
product
public interfaceWork {
void doWork();
}
ConcreteProduct
public classStudentWork implements Work {
public void doWork() {
System.out.println("学生做作业!");
}
}
public class TeacherWorkimplements Work {
public void doWork() {
System.out.println("老师审批作业!");
}
}
Creator
public interfaceIWorkFactory {
Work getWork();
}
ConcreteCreator
public class StudentWorkFactoryimplements IWorkFactory {
public Work getWork() {
return new StudentWork();
}
}
public classTeacherWorkFactory implements IWorkFactory {
public Work getWork() {
return new TeacherWork();
}
}
Test
public class Test{
public static void main(String[] args) {
IWorkFactory studentWorkFactory = newStudentWorkFactory();
studentWorkFactory.getWork().doWork();
IWorkFactory teacherWorkFactory = newTeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}
}
本人改造：
public class Test{
public static void main(String[] args) {
IWorkFactory studentWorkFactory = newStudentWorkFactory();
Work studentWork = studentWorkFactory.getWork();
studentWork.doWork();
IWorkFactory teacherWorkFactory = newTeacherWorkFactory();
Work teatherWork = teacherWorkFactory.getWork();
teatherWork.doWork();
}
}
result
学生做作业!
老师审批作业!
形象比喻：
FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
1.1.2抽象工厂（AbstractFactory）
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性
1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系列中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
参与者
1.AbstractFactory
声明一个创建抽象产品对象的操作接口。
2.ConcreteFactory
实现创建具体产品对象的操作。
3.AbstractProduct
为一类产品对象声明一个接口。
4.ConcreteProduct
定义一个将被相应的具体工厂创建的产品*象。
实现abstractProduct接口。
5.Client
仅使用由AbstractFactory和AbstractProduct类声明的接口
类图
《Java与模式》中的图：
例子
abstractFactory
public interfaceIAnimalFactory {
ICat createCat();
IDog createDog();
}
ConcreteFactory
public classBlackAnimalFactory implements IAnimalFactory {
public ICat createCat() {
return new BlackCat();
}
public IDog createDog() {
return new BlackDog();
}
}
public classWhiteAnimalFactory implements IAnimalFactory {
public ICat createCat() {
return new WhiteCat();
}
public IDog createDog() {
return new WhiteDog();
}
}
AbstractProduct
public interfaceICat {
void eat();
}
public interfaceIDog {
void eat();
}
Concreteproduct
public class BlackCatimplements ICat {
public void eat() {
System.out.println("The black catis eating!");
}
}
public classWhiteCat implements ICat {
public void eat() {
System.out.println("The white catis eating!*);
}
}
public classBlackDog implements IDog {
public void eat() {
System.out.println("The black dogis eating");
}
}
public classWhiteDog implements IDog {
public void eat() {
System.out.println("The white dogis eating!");
}
}
Client
public static voidmain(String[] args) {
IAnimalFactory blackAnimalFactory = newBlackAnimalFactory();
ICat blackCat =blackAnimalFactory.createCat();
blackCat.eat();
IDog blackDog =blackAnimalFactory.createDog();
blackDog.eat();
IAnimalFactory whiteAnimalFactory = newWhiteAnimalFactory();
ICat whiteCat =whiteAnimalFactory.createCat();
whiteCat.eat();
IDog whiteDog =whiteAnimalFactory.createDog();
whiteDog.eat();
}
result
The black cat iseating!
The black dog iseating!
The white cat iseating!
The white dog is eating!
形象比喻：
ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory
工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。
1.1.3建造者模式（Builder）
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用性
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须允许被构造的对象有不同的表示时。
参与者
1.Builder
为创建一个Product对象的各个部件指定抽象接口。
2.ConcreteBuilder
实现Builder的接口以构造和装配该产品的各个部件。
定义并明确它所创建的表示。
提供一个检索产品的接口。
3.Director
构造一个使用Builder接口的对象。
4.Product
表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
类图
例子
Builder
public interfacePersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}
ConcreteBuilder
public classManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Man();
}
public void buildbody() {
person.setBody("建造男人的身体");
}
public void buildFoot() {
person.setFoot("建造男人的脚");
}
public void buildHead() {
person.setHead("建造男人的头");
}
public Person buildPerson() {
return person;
}
}
Director
public classPersonDirector {
public Person constructPerson(PersonBuilderpb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
Product
public classPerson {
private String head;
private String body;
private Stringfoot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
}
public class Manextends Person {
}
Test
public class Test{
public static void main(String[] args) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(newManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}
result
建造男人的身体
建造男人的脚
建造男人的头
形象比喻：
BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞定，这就是我的“我爱你 ”builder。（这一定比美军在伊拉克用的翻译机好卖）
建造模式：将对象的内部表象和对象的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。
1.1.4单态模式（Singleton）
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用性
1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
参与者
Singleton
定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。
可能负*创建它自己的唯一实例。
类图
例子
Singleton
public classSingleton {
private static Singleton sing;
private Singleton() {
}
public static SingletongetInstance() {
if (sing == null) {
sing = new Singleton();
}
return sing;
}
}
Test
public class Test{
public static void main(String[] args) {
Singleton sing =Singleton.getInstance();
Singleton sing2 = Singleton.getInstance();
System.out.println(sing);
System.out.println(sing2);
}
}
result
singleton.Singleton@1c78e57
形象比喻：
SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)
单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。
1.1.5 原型模式（Prototype）
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性
1.当一个系统应该独立于它的产品创建、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂类层次时。
4.当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
参与者
1. Prototype
声明一个克隆自身的接口。
2. ConcretePrototype
实现一个克隆自身的操作。
3. Client
让一个原型克隆自身从而创建一个新的对象。
类图
例子
Prototype
public classPrototype implements Cloneable {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public Object clone(){
try {
return super.clone();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
ConcretePrototype
public classConcretePrototype extends Prototype {
public ConcretePrototype(String name) {
setName(name);
}
}
Client
public class Test{
public static void main(String[] args) {
Prototype pro = new ConcretePrototype("prototype");
Prototype pro2 =(Prototype)pro.clone();
System.out.println(pro.getName());
System.out.println(pro2.getName());
}
}
result
prototype
prototype
形象比喻：
PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）
原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。
1.2结构型模式
Adapter ( 适配器模式 )
Bridge ( 桥接模式 )
Composite ( 组合模式 )
Decorator ( 装饰模式 )
Facade ( 外观模式 )
Flyweight ( 享元模式 )
Proxy ( 代理模式 )
1.2.1适配器模式（Adapter）
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适用性
1.你想使用一个已经存在的类，而它的接口不符合你的需求。
2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
3.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
参与者
1.Target
定义Client使用的与特定领域相关的接口。
2.Client
与符合Target接口的对象协同。
3.Adaptee
定义一个已经存在的接口，这个接口需要适配。
4.Adapter
对Adaptee的接口与Target接口进行适配
类图
例子
Target
public interfaceTarget {
void adapteeMethod();
void adapterMethod();
}
Adaptee
public classAdaptee {
public void adapteeMethod() {
System.out.println("Adapteemethod!");
}
}
Adapter
public classAdapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void adapteeMethod() {
adaptee.adapteeMethod();
}
public void adapterMethod() {
system.out.println("Adaptermethod!");
}
}
Client
public class Test{
public static void main(String[] args) {
Target target = new Adapter(newAdaptee());
target.adapteeMethod();
target.adapterMethod();
}
}
result
Adaptee method!
Adapter method!
形象比喻：
ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)
适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。
1.2.2桥接模式（Bridge）
将抽象部分与它的实现部分分离，使它们都可以独立地变化。
适用性
1.你不希望在抽象和它的实现部分之间有一个固定的绑定关系。
例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。
2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。
这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
4.（C++）你想对客户完全隐藏抽象的实现部分。在C++中，类的表示在类接口中是可见的
有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。Rumbaugh 称这种类层次结构为“嵌套的普化”（nested generalizations ）。
5.你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。一个简单的例子便是Coplien 的String 类[ C o p 9 2 ]，在这个类中多个对象可以共享同一个字符串表示（S t r i n g R ep ）。
参与者
1.Abstraction
定义抽象类的接口。
维护一个指向Implementor类型对象的指针。
2.RefinedAbstraction
扩充由Abstraction定义的接口。
3.Implementor
定义实现类的接口，该接口不一定要与Abstraction的接口完全一致。
事实上这两个接口可以完全不同。
一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。
4.ConcreteImplementor
实现Implementor接口并定义它的具体实现。
类图
例子
Abstraction
public abstractclass Person {
private Clothing clothing;
private String type;
public Clothing getClothing() {
return clothing;
}
public void setClothing() {
this.clothing = clothingFactory.getClothing();//有问题！
}
public void setType(String type) {
this.type = type;
}
public String getType() {
return this.type;
}
public abstract void dress();
}
RefinedAbstraction
public class Manextends person {
public Man() {
setType("男人");
}
public void dress() {
Clothing clothing = getclothing();
clothing.personDressCloth(this);
}
}
public class Ladyextends Person {
public Lady() {
setType("女人");
}
public void dress() {
Clothing clothing = getClothing();
clothing.personDressCloth(this);
}
}
Implementor
public abstractclass Clothing {
public abstract void personDressCloth(personperson);
}
ConcreteImplementor
public class jacketextends Clothing {
public void personDressCloth(Person person){
System.out.println(person.getType() +"穿马甲");
}
}
public classTrouser extends Clothing {
public void personDressCloth(Person person){
System.out.println(person.getType() +"穿裤子");
}
}
Test
public class Test{
public static void main(String[] args) {
Person man = new Man();
Person lady = new Lady();
Clothing jacket = new Jacket();
Clothing trouser = new Trouser();
jacket.personDressCloth(man);
trouser.personDressCloth(man);
jacket.personDressCloth(lady);
trouser.personDressCloth(lady);
}
}
result
男人穿马甲
男人穿裤子
女人穿马甲
女人穿裤子
形象比喻：
BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了
桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
1.2.3组合模式（Composite）
将对象组合成树形结构以表示"部分-整体"的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。
适用性
1.你想表示对象的部分-整体层次结构。
2.你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
参与者
1.Component
为组合中的对象声明接口。
在适当的情况下，实现所有类共有接口的缺省行为。
声明一个接口用于访问和管理Component的子组件。
(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合*的情况下实现它。
2.Leaf
在组合中表示叶节点对象，叶节点没有子节点。
在组合中定义节点对象的行为。
3.Composite
定义有子部件的*些部件的行为。
存储子部件。
在Component接口中实现与子部件有*的操作。
4.Client
通过Component接口操纵组合部件的对象。
类图（另外找的）
例子
Component
public abstractclass Employer {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public abstract void add(Employer employer);
public abstract void delete(Employeremployer);
public List employers;
public void printInfo() {
System.out.println(name);
}
public List getEmployers() {
return this.employers;
}
}
Leaf
public classProgrammer extends Employer {
public Programmer(String name) {
setName(name);
employers = null;//程序员,表示没有下属了
}
public void add(Employer employer) {
}
public void delete(Employer employer) {
}
}
public class ProjectAssistantextends Employer {
public ProjectAssistant(String name) {
setName(name);
employers = null;//项目助理,表示没有下属了
}
public void add(Employer employer) {
}
public void delete(Employer employer) {
}
}
Composite
public classProjectManager extends Employer {
public ProjectManager(String name) {
setName(name);
employers = new ArrayList();
}
public void add(Employer employer) {
employers.add(employer);
}
public void delete(Employer employer) {
employers.remove(employer);
}
}
Client
public class Test{
public static void main(String[] args) {
Employer pm = new ProjectManager("项目经理");
Employer pa = newProjectAssistant("项目助理");
Employer programmer1 = newProgrammer("程序员一");
Employer programmer2 = newProgrammer("程序员二");
pm.add(pa);//为项目经理添加项目助理
pm.add(programmer2);//为项目经理添加程序员
List ems = pm.getEmployers();
for (Employer em : ems) {
System.out.println(em.getName());
}
}
}
result
项目助理
程序员二
形象比喻：
COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。 ”“……”，MM都会用Composite模式了，你会了没有？
合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
1.2.4装饰模式（Decorator）
动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。
适用性
1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
2.处理那些可以撤销的职责。
3.当不能采用生成子类的方法进行扩充时。
参与者
1.Component
定义一个对象接口，可以给这些对象动态地添加职责。
2.ConcreteComponent
定义一个对象，可以给这个对象添加一些职责。
3.Decorator
维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。
4.ConcreteDecorator
向组件添加职责。
类图
例子
Component
public interfacePerson {
void eat();
}
ConcreteComponent
public class Manimplements Person {
public void eat() {
System.out.println("男人在吃");
}
}
Decorator
public abstractclass Decorator implements Person {
protected Person person;
public void setPerson(Person person) {
this.person = person;
}
public void eat() {
person.eat();
}
}
ConcreteDec*rator
public classManDecoratorA extends Decorator {
public void eat() {
super.eat();
reEat();
System.out.println("ManDecoratorA类");
}
public void reEat() {
System.out.println("再吃一顿饭");
}
}
public class ManDecoratorBextends Decorator {
public void eat() {
super.eat();
System.out.println("===============");
System.out.println("ManDecoratorB类");
}
}
Test
public class Test{
public static void main(String[] args) {
Man man = new Man();
ManDecoratorA md1 = newManDecoratorA();
ManDecoratorB md2 = newManDecoratorB();
md1.setPerson(man);
md2.setPerson(md1);
md2.eat();
}
}
result
男人在吃
再吃一顿饭
ManDecoratorA类
===============
ManDecoratorB类
1.2.5外观模式（Facade）
为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
适用性
1.当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。
2.客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。
3.当你需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。
参与者
1.Facade
知道哪些子系统类负责处理请求。
将客户的请求代理给适当的子系统对象。
2.Subsystemclasses
实现子系统的功能。
处理由Facade对象指派的任务。
没有facade的任何相关信息；即没有指向Facade的指针。
类图
例子
Facade
public classFacade {
ServiceA sa;
ServiceB sb;
ServiceC sc;
public Facade() {
sa = new ServiceAImpl();
sb = new ServiceBImpl();
sc = new ServiceCImpl();
}
public void methodA() {
sa.methodA();
sb.methodB();
}
public void methodB() {
sb.methodB();
sc.methodC();
}
public void methodC() {
sc.methodC();
sa.methodA();
}
}
Subsystemclasses
public classServiceAImpl implements ServiceA {
public void methodA() {
System.out.println("这是服务A");
}
}
public classServiceBImpl implements ServiceB {
public void methodB() {
System.out.println("这是服务B");
}
}
public classServiceCImpl implements ServiceC {
public void methodC() {
System.out.println("这是服务C");
}
}
Test
public class Test{
public static void main(String[] args) {
ServiceAsa = new ServiceAImpl();
ServiceBsb = new ServiceBImpl();
sa.methodA();
sb.methodB();
System.out.println("========");
//facade
Facade facade = new Facade();
facade.methodA();
facade.methodB();
}
}
result
这是服务A
这是服务B
========
这是服务A
这是服务B
这是服务B
这是服务C
1.2.6享元模式（Flyweight）
运用共享技术有效地支持大量细粒度的对象。
适用性
当都具备下列情况时，使用Flyweight模式：
1.一个应用程序使用了大量的对象。
2.完全由于使用大量的对象，造成很大的存储开销。
3.对象的大多数状态都可变为外部状态。
4.如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。
5.应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。
参与者
1.Flyweight
描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。
2.ConcreteFlyweight
实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。
ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。
3.UnsharedConcreteFlyweight
并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。
在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。
4.FlyweightFactory
创建并管理flyweight对象。
确保合理地共享flyweight。当用户请求一个flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。
类图
例子
Flyweight
public interfaceFlyweight {
void action(int arg);
}
ConcreteFlyweight
public classFlyweightImpl implements Flyweight {
public void action(int arg) {
// TODO Auto-generated method stub
System.out.println("参数值: " + arg);
}
}
FlyweightFactory
public classFlyweightFactory {
private static Map flyweights = newHashMap();
public FlyweightFactory(String arg) {
flyweights.put(arg, new FlyweightImpl());
}
public static Flyweight getFlyweight(Stringkey) {
if (flyweights.get(key) == null) {
flyweights.put(key, newFlyweightImpl());
}
return flyweights.get(key);
}
public static int getSize() {
return flyweights.size();
}
}
Test
public class Test{
public static void main(String[] args) {
// TODO Auto-generated method stub
Flyweight fly1 = FlyweightFactory.getFlyweight("a");
fly1.action(1);
Flyweight fly2 = FlyweightFactory.getFlyweight("a");
System.out.println(fly1 == fly2);
Flyweight fly3 =FlyweightFactory.getFlyweight("b");
fly3.action(2);
Flyweight fly4 = FlyweightFactory.getFlyweight("c");
fly4.action(3);
Flyweight fly5 =FlyweightFactory.getFlyweight("d");
fly4.action(4);
System.out.println(FlyweightFactory.getSize());
}
}
result
参数值: 1
true
参数值: 2
参数值: 3
参数值: 4
4
1.2.7代理模式（Proxy）
为其他对象提供一种代理以控制对这个对象的访问。
适用性
在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用Proxy 模式。下面是一些可以使用Proxy 模式常见情况：
1.远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。
2.虚代理（VirtualProxy）根据需要创建开销很大的对象，使得此对象只在需要时才会真正创建。
3.保护代理（ProtectionProxy）控制对原始对象的访问。
4.智能指引（SmartReference）取代了简单的指针，它在访问对象时执行一些附加操作。
5.防火墙代理，保护目标，不让恶意用户接近。
参与者
1.Proxy
保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。
提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。
控制对实体的*取，并可能负责创建和删除它。
其他功能依赖于*理的类型：
2.RemoteProxy负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求。
3.VirtualProxy可以缓存实体的附加信息，以便延迟对它的访问。
4.ProtectionProxy检查调用者是否具有实现一个请求所必需的访问权限。
5.Subject
定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都*以使用Proxy。
6.RealSubject
定义Proxy所代表的实体。
类图
例子
Proxy
public classProxyObject implements Object {
Object obj;
public ProxyObject() {
System.out.println("这是代理类");
obj = new ObjectImpl();
}
public void action() {
System.out.println("代理开始");
obj.action();
System.out.println("代理结束");
}
}
Subject
public interfaceObject {
void action();
}
RealSubject
public classObjectImpl implements Object {
public void action() {
System.out.println("========");
System.out.println("========");
System.out.println("这是被代理的类");
System.out.println("========");
System.out.println("========");
}
}
Test
public class Test{
public static void main() {
Objectobj = new ProxyObject();
obj.action();
}
}
result
这是代理类
代理开始
========
========
这是被代理的类
========
========
代理结束
自己在网上找的另外的例子：
抽象角色:
abstract publicclass Subject{
abstract publicvoid request();
}
真实角色: 实现了Subject 的request()方法。
public classRealSubject extends Subject{
public RealSubject(){ }
public voidrequest(){
System.out.println("From real subject.");
}
}
代理角色:
public classProxySubject extends Subject{
private RealSubjectrealSubject; 以真实角色作为代理角色的属性
publicProxySubject() { }
public voidrequest() { 该方法封装了真实对象的request方法
preRequest();
if ( realSubject ==null ) {
realSubject = newRealSubject();
}
realSubject.request();此处执行真实对象的request方法
postRequest();
}
客户端调用:
Subject sub = newProxySubject();
Sub.request();
由以上代码可以看出, 客户实际需要调用的是RealSubject 类的request () 方法, 现在用ProxySubject 来代理RealSubject 类, 同样达到目的, 同时还封装了其他方法(preRequest(),postRequest()), 可以处理一些其他问题。如果要按照上述的方法使用代理模式, 那么真实角色必须是事先已经存在的, 并将其作为代理对象的内部属性
1.3行为型模式
Chain of Responsibility ( 责任链模式 )
Command ( 命令模式 )
Interpreter ( 解释器模式 )
Iterator ( 迭代器模式 )
Mediator ( 中介者模式 )
Memento ( 备忘录模式 )
Observer ( 观察者模式 )
State ( 状*模式 )
Strategy ( 策略模式 )
TemplateMethod ( 模板方法 )
Vis*tor ( 访问者模式 )
1.3.1责任链模式（Chain of Responsibility）
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者.
适用性
1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2.你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3.可处理一个请求的对象集合应被动态指定。
参与者
1.Handler
定义一个处理请求的接口。
（可选）实现后继链。
2.ConcreteHandler
处理它所负责的请求。
可访问它的后继者。
如果可处理该请求，就处理它；否则将该请求转发给它的后继者。
3.Client
向链上的具体处理者(ConcreteHandler)对象提交请求。
类图（另寻）
例子
Handler
public interfaceRequestHandle {
void handleRequest(Request request);
}
ConcreteHandler
public classHRRequestHandle implements RequestHandle {
public void handleRequest(Request request){
if (request instanceofDimissionRequest) {
System.out.println("要离职,人事审批!");
}
System.out.println("请求完毕");
}
}
public classPMRequestHandle implements RequestHandle {
RequestHandle rh;
public PMRequestHandle(RequestHandle rh) {
this.rh = rh;
}
public void handleRequest(Request request){
if (request instanceof AddMoneyRequest){
System.out.println("要加薪,项目经理审批!");
} else {
rh.handleRequest(request);
}
}
}
public classTLRequestHandle implements RequestHandle {
RequestHandle rh;
public TLRequestHandle(RequestHandle rh) {
this.rh = rh;
}
public void handleRequest(Request request){
if (request instanceof LeaveRequest) {
System.out.println("要请假,项目组长审批!");
}else {
rh.handleRequest(request);
}
}
}
Client
public class Test{
public static void main(String[] args) {
RequestHandle hr = new HRRequestHandle();
RequestHandle pm = new PMRequestHandle(hr);
RequestHandle tl = newTLRequestHandle(pm);
//team leader处理离职请求
Request request = newDimissionRequest();
tl.handleRequest(request);
System.out.println("===========");
//team leader处理加薪请求
request = new AddMoneyRequest();
tl.handleRequest(request);
System.out.println("========");
//项目经理上理辞职请求
request = new DimissionRequest();
pm.handleRequest(request);
}
}
result
要离职, 人事审批!
请求完毕
===========
要加薪, 项目经理审批!
========
要离职, 人事审批!
请求完毕
另外：
责任链模式并不创建责任链，责任链的创建必须由系统的其他部分创建出来。
责任链模式不指定责任链的拓扑结构，一个链可以是一条线、一个树，也可以是一个环；链的拓扑结构可以是单连通或多连通
责任链模式要求在同一个时间里，命令只可以传给一个下家（或处理掉），不可以传给多个下家
在一个责任链上可以传递数个命令。
形象比喻：
CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处女呀，快跑!
责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。
1.3.2命令模式（Command）
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
适用性
抽象出待执行的动作以参数化某对象。
可用过程语言中的回调（callback）函数表达这种参数化机制。所谓回调函数是指函数先在某处注册，而它将在稍后某个需要的时候被调用。Command模式是回调机制的一个面向对象的替代品。
在不同的时刻指定、排列和执行请求。
一个Command对象可以有一个与初始请求无关的生存期。如果一个请求的接收者可用一种与地址空间无关的方式表达，那么就可将负责该请求的命令对象传送给另一个不同的进程并在那儿实现该请求。
支持取消操作。
Command 的Excute操作可在实施操作前将状态存储起来，在取消操作时这个状态用来消除该操作的影响。Command接口必须添加一个Unexecute操作，该操作取消上一次Execute调用的效果。执行的命令被存储在一个历史列表中。可通过向后和向前遍历这一列表并分别调用Unexecute和Execute 来实现重数不限的“取消”和“重做”。
支持修改日志，这样当系统崩溃时，这些修改可以被重做一遍。
在Command接口中添加装载操作和存储操作，可以用来保持变动的一个一致的修改日志。从崩溃中恢复的过程包括从磁盘中重新读入记录下来的命令并用Execute操作重新执行它们。
用构建在原语操作上的高层操作构造一个系统。
这样一种结构在支持事务( transaction )的信息系统中很常见。一个事务封装了对数据的一组变动。Command模式提供了对事务进行建模的方法。Command有一个公共的接口，使得你可以用同一种方式调用所有的事务。同时使用该模式也易于添加新事务以扩展系统。
参与者
1.Command
声明执行操作的接口。
2.ConcreteCommand
将一个接收者对象绑定于一个动作。
调用接收者相应的操作，以实现Execute，负责调用命令对象执行请求。
命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
3.Client
创建一个具体命令对象并设定它的接收者。
创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。
4.Invoker
要求该命令执行这个请求。
要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
5.Receiver
知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。
接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
类图
例子
Command
public abstract classCommand {
protected Receiver receiver;
public Command(Receiver receiver) {
this.receiver = receiver;
}
public abstract void execute();
}
ConcreteCommand
public classCommandImpl extends Command {
public CommandImpl(Receiver receiver) {
super(receiver);
}
public void execute() {
receiver.request();
}
}
Invoker
public classInvoker {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void execute() {
command.execute();
}
}
Receiver
public classReceiver {
public void receive() {
System.out.println("This isReceive class!");
}
}
Test
public class Test{
pubbic static void main(String[] args) {
Receiver rec = new Receiver();
Command cmd = new CommandImpl(rec);
Invoker i = new Invoker();
i.setCommand(cmd);
i.execute();
}
}
result
This is Receiveclass!
补充：
接收者Receiver才是真正的命令执行者。
形象比喻：
COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。”
命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。
1.3.3解释器模式（Interpreter）
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
适用性
当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：
1.该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理。
2.效率不是一个关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下,转换器仍可用解释器模式实现, 该模式仍是有用的。
参与者
1.AbstractExpression(抽象表达式)
声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
2.TerminalExpression(终结符表达式)（应该是AdvanceExpression）
实现与文法中的终结符相关联的解释操作。
一个句子中的每个终结符需要该类的一个实例。
3.NonterminalExpression(非终结符表达式)（应该是SimpleExpression）
为文法中的非终结符实现解释(Interpret)操作。
4.Context（上下文）
包含解释器之外的一些全局信息。
5.Client（客户）
构建(或被给定)表示该文法定义的语言中*个特定的句子的抽象*法树。
该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。
调用解*操作。
类图
例子
AbstractExpression
public abstractclass Expression {
abstract void interpret(Context ctx);
}
Expression
public classAdvanceExpression extends Expression {
void interpret(Context ctx) {
System.out.println("这是高级解析器!");
}
}
public classSimpleExpression extends Expression {
void interpret(Context ctx) {
System.out.println("这是普通解析器!");
}
}
Context
public class Context{
private String content;
private List list = new ArrayList();
public void setContent(String content) {
this.content = content;
}
public String getContent() {
return this.content;
}
public void add(Expression eps) {
list.add(eps);
}
public List getList() {
return list;
}
}
Test
public class Test{
public static void main(String[] args) {
Context ctx = new Context();
ctx.add(new SimpleExpression());
ctx.add(new AdvanceExpression());
ctx.add(new SimpleExpression());
for (Expression eps : ctx.getList()) {
eps.interpret(ctx);
}
}
}
result
这是普通解析器!
这是高级解析器!
这是普通解析器!
形象比喻：
INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着上面的脚本执行就可以了。
解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。
1.3.4迭代器模式（Iterator）
提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。
适用性
1.访问一个聚合对象的内容而无需暴露它的内部表示。
2.支持对聚合对象的多种遍历。
3.为遍历不同的聚合结构提供一个统一的接口(即,支持多态迭代)。
参与者
1.Iterator
迭代器定义访问和遍历元素的接口。
2.ConcreteIterator
具体迭代器实现迭代器接口。
对该聚合遍历时跟踪当前位置。
3.Aggregate
聚合定义创建相应迭代器对象的接口。
4.ConcreteAggregate
具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例.
类图
例子
Iterator
public interfaceIterator {
Object next();
void first();
void last();
boolean hasNext();
}
ConcreteIterator
public classIteratorImpl implements Iterator {
private List list;
private int index;
public IteratorImpl(List list) {
index = 0;
this.list = list;
}
public void first() {
index = 0;
}
public void last() {
index = list.getSize();
}
public Object next() {
Object obj = list.get(index);
index++;
return obj;
}
public boolean hasNext() {
return index < list.getSize();
}
}
Aggregate
public interfaceList {
Iterator iterator();
Object get(int index);
int getSize();
void add(Object obj);
}
ConcreteAggregate
public classListImpl implements List {
private Object[] list;
private int index;
private int size;
public ListImpl() {
index = 0;
size = 0;
list = new Object[100];
}
public Iterator iterator() {
return new IteratorImpl(this);
}
public Object get(int index) {
return list[index];
}
public int getSize() {
return this.size;
}
public void add(Object obj) {
list[index++] = obj;
size++;
}
}
Test
public class Test{
public static void main(String[] args) {
List list = new ListImpl();
list.add("a");
list.add("b");
list.add("c");
//第一种迭代方式
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("=====");
//第二种迭代方式
for (int i = 0; i < list.getSize();i++) {
System.out.println(list.get(i));
}
}
}
result
a
b
c
=====
a
b
c
形象比喻：
我爱上了Mary，不顾一切的向她求婚。
Mary：“想要我跟你结婚，得答应我的条件”
我：“什么条件我都答应，你说吧”
Mary：“我看上了那个一克拉的钻石”
我：“我买，我买，还有吗？”
Mary：“我看上了湖边的那栋别墅”
我：“我买，我买，还有吗？”
Mary：“我看上那辆法拉利跑车”
我脑袋嗡的一声，坐在椅子上，一咬牙：“我买，我买，还有吗？”
迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。
1.3.5中介者模式（Mediator）
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
适用性
1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。
参与者
1.Mediator
中介者定义一个接口用于与各同事（Colleague）对象通信。
2.ConcreteMediator
具体中介者通过协调各同事对象实现协作行为*
了解并维护它的各个同事。
3.Colleagueclass
每一个同事类都知道它的中介者对象。
每一个同事对象在需与其他的同事通信的时候*与它的中介者通信
类图
例子
Mediator
public abstractclass Mediator {
public abstract void notice(Stringcontent);
}
ConcreteMediator
public classConcreteMediator extends Mediator {
private ColleagueA ca;
private ColleagueB cb;
public ConcreteMediator() {
ca = new ColleagueA();
cb = new ColleagueB();
}
public void notice(String content) {
if (content.equals("boss")) {
//老板来了,通知员工A
ca.action();
}
if (content.equals("client")){
//客户来了,通知前台B
cb.action();
}
}
}
Colleagueclass
public classColleagueA extends colleague {
public void action() {
System.out.println("普通员工努力工作");
}
}
public classColleagueB extends Colleague {
public void action() {
System.out.println("前台注意了!");
}
}
Test
public class Test{
public static void main(String[] args) {
Mediator med = new ConcreteMediator();
//老板来了
med.notice("boss");
//客户来了
med.notice("client");
}
}
result
普通员工努力工作
前台注意了!
形象比喻：
MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。
调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。
1.3.6备忘录模式（Memento）
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
适用性
1.必须保存一个对象在某一个时刻的(部分)状态,这样以后需要时它才能恢复到先前的状态。
2.如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。
参与者
1.Memento
备忘录存储原发器对象的内部状态。
2.Originator
原发器创建一个备忘录,用以记录当前时刻*的内部状态。
使用备忘录恢复内部状态.
3.Caretaker
负责保存好备忘录。
不能对备忘录的内*进行操作或检查。
类图
例子
Memento
public classMemento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
Originator
public classOriginator {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public Memento createMemento() {
return new Memento(state);
}
public void setMemento(Memento memento) {
state = memento.getState();
}
public void showState(){
System.out.println(state);
}
}
Caretaker
public class Caretaker{
private Memento memento;
public Memento getMemento(){
return this.memento;
}
public void setMemento(Memento memento){
this.memento = memento;
}
}
Test
public class Test{
public static void main(String[] args) {
Originator org = new Originator();
org.setState("开会中");
Caretaker ctk = new Caretaker();
ctk.setMemento(org.createMemento());//将数据封装在Caretaker
org.setState("睡觉中");
org.showState();//显示
org.setMemento(ctk.getMemento());//将数据重新导入
org.showState();
}
}
result
睡觉中
开会中
形象比喻：
MEMENTO—同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与哪个MM说了什么话我都拷贝一份放到备忘录里面保存，这样可以随时察看以前的记录啦。
备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
1.3.7观察者模式（Observer）
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
适用性
1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。
将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2.当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变。
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁。
参与者
1.Subject（目标）
目标知道它的观察者。可以有任意多个观察者观察同一个目标。
提供注册和删除观察者对象的接口。
2.Observer（观察者）
为那些在目标发生改变时需获得通知的对象定义一个更新接口。
3.ConcreteSubject（具体目标）
将有关状态存入各ConcreteObserver对象。
当它的状态发生改变时,向它的各个观察者发出通知。
4.ConcreteObserver（具体观察者）
维护一个指向ConcreteSubject对象的引用。
存储有关状态，这些状态应与目标的状态保持一致。
实现Observer的更新接口*使自身状态与目标的状态保持一致
类图
例子
Subject
public abstractclass Citizen {
List pols;
String help = "normal";
public void setHelp(String help) {
this.help = help;
}
public String getHelp() {
return this.help;
}
abstract void sendMessage(String help);
public void setPolicemen() {
this.pols = new ArrayList();
}
public void register(policeman pol) {
this.pols.add(pol);
}
public void unRegister(Policeman pol) {
this.pols.remove(pol);
}
}
Observer
public interfacePoliceman {
void action(Citizen ci);
}
ConcreteSubject
public class HuangPuCitizenextends Citizen {
public HuangPuCitizen(Policeman pol) {
setPolicemen();
register(pol);
}
public void sendMessage(String help) {
setHelp(help);
for(int i = 0; i < pols.size(); i++){
Policeman pol = pols.get(i);
//通知警察行动
pol.action(this);
}
}
}
public classTianHeCitizen extends Citizen {
public TianHeCitizen(Policeman pol) {
setPolicemen();
register(pol);
}
public void sendMessage(String help) {
setHelp(help);
for (int i = 0; i < pols.size();i++) {
Policeman pol = pols.get(i);
//通知警察行动
pol.action(this);
}
}
}
ConcreteObserver
public classHuangPuPoliceman implements Policeman {
public void action(Citizen ci) {
String help = ci.getHelp();
if (help.equals("normal")) {
System.out.println("一切正常,不用出动");
}
if (help.equals("unnormal")) {
System.out.println("有犯罪行为,黄埔警察出动!");
}
}
}
public classTianHePoliceman implements Policeman {
public void action(Citizen ci) {
String help = ci.getHelp();
if (help.equals("normal")) {
System.out.println("一切正常,不用出动");
}
if (help.equals("unnormal")){
System.out.println("有犯罪行为,天河警察出动!");
}
}
}
Test
public class Test{
public static void main(String[] args) {
Policeman thPol = new TianHePoliceman();
Policeman hpPol = newHuangPuPoliceman();
Citizen citizen = newHuangPuCitizen(hpPol);
citizen.sendMessage("unnormal");
citizen.sendMessage("normal");
System.out.println("===========");
citizen = new TianHeCitizen(thPol);
citizen.sendMessage("normal");
citizen.sendMessage("unnormal");
}
}
result
有犯罪行为, 黄埔警察出动!
一切正常, 不用出动
===========
一切正常, 不用出动
有犯罪行为, 天河警察出动!
形象比喻：
OBSERVER—想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，我们作为订阅者（观察者）就可以及时收到情报啦
观察者模式：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。
1.3.8状态模式（State）
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
适用性
1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。
2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
这个状态通常用一个或多个枚举常量表示。
通常,有多个操作包含这一相同的条件结构。
State模式将每一个条件分支放入一个独立的类中。
这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。
参与者
1.Context
定义客户感兴趣的接口。
维护一个ConcreteState子类的实例，这个实例定义当前状态。
2.State
定义一个接口以封装与Context的一个特定状态相关的行为。
3.ConcreteStatesubclasses
每一子类实现一个与Context的一个状态*关的行为。
类图
例子
Context
public classContext {
private Weather weather;
public void setWeather(Weather weather) {
this.weather = weather;
}
public Weather getWeather() {
return this.weather;
}
public String weatherMessage() {
return weather.getWeather();
}
}
State
public interfaceWeather {
String getWeather();
}
Concrete*tatesubclasses
public class Rainimplements Weather {
public String getWeather() {
return "下雨";
}
}
public classSunshine implements Weather {
public String getWeather() {
return "阳光";
}
}
Test
public class Test{
public static void main(String[] args) {
Context ctx1 = new Context();
ctx1.setWeather(new Sunshine());
System.out.println(ctx1.weatherMessage());
System.out.println("===============");
Context ctx2 = new Context();
ctx2.setWeather(new Rain());
System.out.println(ctx2.weatherMessage());
}
}
result
阳光
===============
下雨
形象比喻：
STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说 “有事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。
状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。
1.3.9策略模式（Strategy）
定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
适用性
1.许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。
2.需要使用一个算法的不同变体。
3.算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。
4.一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现。
将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。
参与者
1.Strategy
定义所有支持的算法的公共接口。Context使用这个接口来调用某ConcreteStrategy定义的算法。
2.ConcreteStrategy
以Strategy接口实现某具体算法。
3.Context
用一个ConcreteStrateg*对象来配置。
维护一个对Strategy对象的引用。
可定义一个接口来让Stategy访问它的数据。
类图
例子
Strategy
public abstractclass Strategy {
public abstract void method();
}
ConcreteStrategy
public class StrategyImplAextends Strategy {
public void method() {
System.out.println("这是第一个实现");
}
}
public classStrategyImplB extends Strategy {
public void method() {
System.out.println("这是第二个实现");
}
}
public classStrategyImplC extends Strategy {
public void method() {
System.out.println("这是第三个实现");
}
}
Context
public classContext {
Strategy stra;
public Context(Strategy stra) {
this.stra = stra;
}
public void doMethod() {
stra.method();
}
}
Test
public class Test{
public static void main(String[] args) {
Context ctx = new Context(newStrategyImplA());
ctx.doMethod();
ctx = new Context(new strategyImplB());
ctx.doMethod();
ctx = new Context(new StrategyImplC());
ctx.doMethod();
}
}
result
这是第一个实现
这是第二个实现
这是第三个实现
形象比喻：
STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。
策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。
1.3.10模板方法（TemplateMethod）
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
适用性
1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。
首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。
最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3.控制子类扩展。
参与者
1.AbstractClass
定义抽象的原语操作（primitiveoperation），具体的子类将重定义它们以实现一个算法的各步骤。
实现一个模板方法,定义一个算法的骨架。
该模板方法不仅调用原语操作，也调用定义在AbstractClass或其他对象中的操作。
2.ConcreteClass
实现*语操作以完成算法中与特定子类相关的步骤。
类图
例子
AbstractClass
public abstractclass Template {
public abstract void print();
public void update() {
System.out.println("开始打印");
for (int i = 0; i < 10; i++) {
print();
}
}
}
ConcreteClass
public classTemplateConcrete extends Template {
@*verride
public void print() {
System.out.println("这是子类的实现");
}
}
Test
public class Test{
public static void main(String[] args) {
Template temp = new TemplateConcrete();
temp.update();
}
}
result
开始打印
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
这是子类的实现
TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗？女生从认识到上床的不变的步骤分为巧遇、打破僵局、展开追求、接吻、前戏、动手、爱抚、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具体实现)；
模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。
1.3.11访问者模式（Visitor）
表示一个作用于某对象结构中的各元素的操作。
它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
适用性
1.一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操*。
2.需要对一个对象结构中的对象进行很多不同的并且不相关的操作，*你想避免让这些操作“污染”这些对象的类。
Visitor使得你可以将相关的操作集中起来定义在一个类中。
当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。
3.定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。
改变对象结构类需要重定义对所有访问者的接口，这可能*要很大的代价。
如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。
参与者
1.Visitor
为该对象结构中ConcreteEle*ent的每一个类声明一个Visit操作。
该操作的名字和特征标识了发送*isit请求给该访问者的那个类。
这使得访问者可以确定正被访问元素*具体的类。
这样访问者就可以通过该元素的特定接口直*访问它。
2.Concret*Visitor
实现每个由Visitor声明的操作。
每个操作实现本算法的一部分，而该算法片断乃是对应于结构中对象的类。
Concret*Visitor*该算法提供了上下文并存*它的局部状态。
这一状态常常在遍历该结构的过程中累*结果。
3.Element
定义一个Accept操作，它*一个访问者为参数。
4.ConcreteElement
实现Accept操作，该操作以一个访问者为参数。
5.ObjectStru*ture
能枚举它的元素。
*以提供一个高层的接口以允许该访问者访问它的元素。
可以是一个复合或是一个集合，如一个列表或一个无序集合。
类图
例子
Visitor
public interfaceVisitor {
public void visitString(StringElementstringE);
public void visitFloat(FloatElementfloatE);
public void visitCollection(Collectioncollection);
}
ConcreteVisitor
public class ConcreteVisitorimplements Visitor {
public void visitCollection(Collectioncollection) {
// TODO Auto-generated method stub
Iterator iterator =collection.iterator();
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof Visitable) {
((Visitable)o).accept(this);
}
}
}
public void visitFloat(FloatElement floatE){
System.out.println(floatE.getFe());
}
public void visitString(StringElement stringE){
System.out.println(stringE.getSe());
}
}
Element
public interfaceVisitable {
public void accept(Visitor visitor);
}
ConcreteElement
public classFloatElement implements Visitable {
private Float fe;
public FloatElement(Float fe) {
this.fe = fe;
}
public Float getFe() {
return this.fe;
}
public void accept(Visitor visitor) {
visitor.visitFloat(this);
}
}
public class StringElementimplements Visitable {
private String se;
public StringElement(String se) {
this.se = se;
}
public String getSe() {
return this.se;
}
public void accept(Visitor visitor) {
visitor.visitString(this);
}
}
Test
public class Test{
public static void main(String[] args) {
Visitor visitor = newConcreteVisitor();
StringElement se = newStringElement("abc");
se.accept(visitor);
FloatElement fe = new FloatElement(newFloat(1.5));
fe.accept(visitor);
S*stem.out.println("===========");
List result = new ArrayList();
result.add(newStringEle*ent("abc"));
result.add(newStringElement("abc"));
result.add(newStringElement("abc"));
result.add(new FloatElement(newFloat(1.5)));
result.add(new FloatElement(newFloat(1.5)));
result.add(new FloatElement(newFloat(1.5)));
visitor.visitCollection(result);
}
}
result
abc
1.5
===========
abc
abc
abc
1.5
1.5
1.5
VISITOR—情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的花都要针对她个人的特点，每张卡片也要根据个人的特点来挑，我一个人哪搞得清楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一束花，让礼品店老板也根据每个人特点选一张卡，这样就轻松多了；
访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。
550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
