Java的23种设计模式(疯狂Java总结)--个人修改增强版 (2)

《Java的23种设计模式(疯狂Java总结)--个人修改增强版 (2)》由会员分享，可在线阅读，更多相关《Java的23种设计模式(疯狂Java总结)--个人修改增强版 (2)（76页珍藏版）》请在装配图网上搜索。

1、Java设计模式（疯狂Java联盟版）个人修改增强版Java设计模式（疯狂Java联盟版）目录1. 设计模式21.1 创建型模式31.1.1 工厂方法（FactoryMethod）31.1.2 抽象工厂（AbstractFactory）61.1.3 建造者模式（Builder）101.1.4 单态模式（Singleton）141.1.5 原型模式（Prototype）151.2 结构型模式181.2.1 适配器模式（Adapter）181.2.2 桥接模式（Bridge）201.2.3 组合模式（Composite）241.2.4 装饰模式（Decorator）281.2.5 外观模式（Fac

2、ade）301.2.6 享元模式（Flyweight）331.2.7 代理模式（Proxy）361.3 行为型模式401.3.1 责任链模式（Chain of Responsibility）401.3.2 命令模式（Command）441.3.3 解释器模式（Interpreter）481.3.4 迭代器模式（Iterator）511.3.5 中介者模式（Mediator）551.3.6 备忘录模式（Memento）581.3.7 观察者模式（Observer）611.3.8 状态模式（State）661.3.9 策略模式（Strategy）681.3.10 模板方法（TemplateMeth

3、od）711.3.11 访问者模式（Visitor）73751. 设计模式内容简介 有感于设计模式在日常开发中的重要性，同时笔者也自觉对设计模式小有心得，故笔者*写二十三种设计模式的简单例子、并整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式（疯狂Java联盟版），希望对大家有所帮助。 本份帮助文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模式的组成部分，并附带有简单的例子和类*，目的是为了让读者了解二十三种设计模式，并能方便的查阅各种设计模式的用法及注意点。 所附的例子非常简单，慢慢的引导读者从浅到深了解设计模式，并能从中享受设计的乐趣。 由于每个人对设计*

4、式的理解都不尽一致，因此，可能本文档的例子*有不恰当的地方，还望各位读者指出不恰当的地方。欢迎登录疯狂Java联盟进行技术交流，疯狂Java联盟的论坛宗旨是： 所有的技术发帖，均有回复。 疯狂Java联盟网址：http:/www.crazyit.org笔者简介 笔者曾师从李刚老师学习Java，现居广州。对Java软件开发、各种Java开源技术都非常感兴趣，曾参与开发、主持*发过大量Java、Java EE项目，对Java、Java *E项目有一定认识*见解。欢迎大家与笔者就Java、Java EE相*方面进行技术交流。 笔者现为疯狂Java联盟的总版主（论坛ID：杨恩雄），也希望通过该平台与大

5、家分享Java、Java EE技术、*得。 本人邮箱：yangenxiong 声明 本文档编写、制作过程中得到了疯狂Java联盟、以及笔者学习工作过程大量朋友的支持，大家都抱着一个目的：为国内软件软件开发事业作出绵薄贡献。 我们在此郑重宣布，本*档遵循Apache 2.0协议。在完整保留全部文本(包括本版权页)，并且不违反Apache 2.0协议的前提下，允许和鼓励任何人进行全文转载及推广，我们放弃除署名权外的一切权利。1.1 创建型模式FactoryMethod ( 工厂方法 ) AbstractFactory ( 抽象工厂 ) Singleton ( 单态模式 ) Builder ( 建造

6、者模式 ) Prototype ( 原型模式 ) 1.1.1 工厂方法（FactoryMethod） 定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。适用性 1.当一个类不知道它所必须创建的对象的类的时候。 2.当一个类希望由它的子类来指定它所创建的对象的时候。 3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。参与者 1.Product 定义工厂方法所创建的对象的接口。 2.ConcreteProduct 实现Product接口。 3.Creator 声明工厂方法，该方法

7、返回一个Product类型的对象* Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。 4.ConcreteCreator 重定义工厂方法以返回一个ConcreteProduct实例。类图Java与模式中的图：例子product public interface Work void doWork();ConcreteProduct public class StudentWork implements Work public void doWork() System.out.println(学生做

8、作业!); public class TeacherWork implements Work public void doWork() System.out.println(老师审批作业!); Creator public interface IWorkFactory Work getWork();ConcreteCreator public class StudentWorkFactory implements IWorkFactory public Work getWork() return new StudentWork(); public class TeacherWorkFactor

9、y implements IWorkFactory public Work getWork() return new TeacherWork(); Test public class Test public static void main(String args) IWorkFactory studentWorkFactory = new StudentWorkFactory(); studentWorkFactory.getWork().doWork(); IWorkFactory teacherWorkFactory = new TeacherWorkFactory(); teacher

10、WorkFactory.getWork().doWork(); 本人改造：public class Test public static void main(String args) IWorkFactory studentWorkFactory = new StudentWorkFactory(); Work studentWork = studentWorkFactory.getWork(); studentWork.doWork(); IWorkFactory teacherWorkFactory = new TeacherWorkFactory(); Work teatherWork

11、= teacherWorkFactory.getWork();teatherWork.doWork(); result 学生做作业!老师审批作业!形象比喻：FACTORY METHOD请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 1.1.2 抽象工厂

12、（AbstractFactory） 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用性 1.一个系统要独立于它的产品的创建、组合和表示时。 2.一个系统要由多个产品系列中的一个来配置时。 3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。 4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。参与者 1.AbstractFactory 声明一个创建抽象产品对象的操作接口。 2.ConcreteFactory 实现创建具体产品对象的操作。 3.AbstractProduct 为一类产品对象声明一个接口。 4.ConcreteProduct 定义一个将被相应

13、的具体工厂创建的产品*象。 实现abstractProduct接口。 5.Client 仅使用由AbstractFactory和AbstractProduct类声明的接口类图 Java与模式中的图：例子abstractFactory public interface IAnimalFactory ICat createCat(); IDog createDog();ConcreteFactory public class BlackAnimalFactory implements IAnimalFactory public ICat createCat() return new BlackCa

14、t(); public IDog createDog() return new BlackDog(); public class WhiteAnimalFactory implements IAnimalFactory public ICat createCat() return new WhiteCat(); public IDog createDog() return new WhiteDog(); AbstractProduct public interface ICat void eat();public interface IDog void eat();Concreteproduc

15、t public class BlackCat implements ICat public void eat() System.out.println(The black cat is eating!); public class WhiteCat implements ICat public void eat() System.out.println(The white cat is eating!*); public class BlackDog implements IDog public void eat() System.out.println(The black dog is e

16、ating); public class WhiteDog implements IDog public void eat() System.out.println(The white dog is eating!); Client public static void main(String args) IAnimalFactory blackAnimalFactory = new BlackAnimalFactory(); ICat blackCat = blackAnimalFactory.createCat(); blackCat.eat(); IDog blackDog = blac

17、kAnimalFactory.createDog(); blackDog.eat(); IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory(); ICat whiteCat = whiteAnimalFactory.createCat(); whiteCat.eat(); IDog whiteDog = whiteAnimalFactory.createDog(); whiteDog.eat();result The black cat is eating!The black dog is eating!The white ca

18、t is eating!The white dog is eating!形象比喻：ABSTRACT FACTORY追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。1.1.3 建造者模式（Builder） 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创

19、建不同的表示。适用性 1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 2.当构造过程必须允许被构造的对象有不同的表示时。参与者 1.Builder 为创建一个Product对象的各个部件指定抽象接口。 2.ConcreteBuilder 实现Builder的接口以构造和装配该产品的各个部件。 定义并明确它所创建的表示。 提供一个检索产品的接口。 3.Director 构造一个使用Builder接口的对象。 4.Product 表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品

20、的接口。类图例子Builder public interface PersonBuilder void buildHead(); void buildBody(); void buildFoot(); Person buildPerson();ConcreteBuilder public class ManBuilder implements PersonBuilder Person person; public ManBuilder() person = new Man(); public void buildbody() person.setBody(建造男人的身体); public vo

21、id buildFoot() person.setFoot(建造男人的脚); public void buildHead() person.setHead(建造男人的头); public Person buildPerson() return person; Director public class PersonDirector public Person constructPerson(PersonBuilder pb) pb.buildHead(); pb.buildBody(); pb.buildFoot(); return pb.buildPerson(); Product publ

22、ic class Person private String head; private String body; private String foot; 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 v

23、oid setFoot(String foot) this.foot = foot; public class Man extends Person Test public class Test public static void main(String args) PersonDirector pd = new PersonDirector(); Person person = pd.constructPerson(new ManBuilder(); System.out.println(person.getBody(); System.out.println(person.getFoot

24、(); System.out.println(person.getHead(); result 建造男人的身体建造男人的脚建造男人的头形象比喻：BUILDERMM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞定，这就是我的“我爱你 ”builder。（这一定比美军在伊拉克用的翻译机好卖） 建造模式：将对象的内部表象和对象的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象

25、可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 1.1.4 单态模式（Singleton）保证一个类仅有一个实例，并提供一个访问它的全局访问点。适用性 1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。参与者 Singleton 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。 可能负*创建它自己的唯一实例。类图例子Singleton public class Singleton private st

26、atic Singleton sing; private Singleton() public static Singleton getInstance() 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(sin

27、g); System.out.println(sing2); result singleton.Singleton1c78e57singleton.Singleton1c78e57形象比喻：SINGLETON俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。1.1.5 原型模式（Prototype）用原型实例指定创建对象的种类，并且通过拷贝这些

28、原型创建新的对象。适用性 1.当一个系统应该独立于它的产品创建、构成和表示时。 2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3.为了避免创建一个与产品类层次平行的工厂类层次时。 4.当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。参与者 1. Prototype 声明一个克隆自身的接口。 2. ConcretePrototype 实现一个克隆自身的操作。 3. Client 让一个原型克隆自身从而创建一个新的对象。类图例子Prototype public class Prototype implemen

29、ts 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 class ConcretePrototype extends Prototype publ

30、ic 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 prototypeprototype形象比喻

31、：PROTOTYPE跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 1.2 结构型模式Adapter ( 适配器模式 ) Bridge ( 桥接模式 ) Composite ( 组合模式 ) Decora

32、tor ( 装饰模式 ) Facade ( 外观模式 ) Flyweight ( 享元模式 ) Proxy ( 代理模式 ) 1.2.1 适配器模式（Adapter） 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适用性 1.你想使用一个已经存在的类，而它的接口不符合你的需求。 2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。 3.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父

33、类接口。参与者 1.Target 定义Client使用的与特定领域相关的接口。 2.Client 与符合Target接口的对象协同。 3.Adaptee 定义一个已经存在的接口，这个接口需要适配。 4.Adapter 对Adaptee的接口与Target接口进行适配类图例子Target public interface Target void adapteeMethod(); void adapterMethod();Adaptee public class Adaptee public void adapteeMethod() System.out.println(Adaptee metho

34、d!); Adapter public class Adapter implements Target private Adaptee adaptee; public Adapter(Adaptee adaptee) this.adaptee = adaptee; public void adapteeMethod() adaptee.adapteeMethod();public void adapterMethod() system.out.println(Adapter method!); Client public class Test public static void main(S

35、tring args) Target target = new Adapter(new Adaptee(); target.adapteeMethod(); target.adapterMethod(); result Adaptee method!Adapter method!形象比喻：ADAPTER在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我) 适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原

36、因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。 1.2.2 桥接模式（Bridge） 将抽象部分与它的实现部分分离，使它们都可以独立地变化。适用性 1.你不希望在抽象和它的实现部分之间有一个固定的绑定关系。 例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。 2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。 这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。 3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。 4.（C+）你想对客户完全隐藏抽象的实现部分。在

37、C+中，类的表示在类接口中是可见的有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。Rumbaugh 称这种类层次结构为“嵌套的普化”（nested generalizations ）。5.你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。一个简单的例子便是Coplien 的String 类 C o p 9 2 ，在这个类中多个对象可以共享同一个字符串表示（S t r i n g R e p ）。参与者 1.Abstraction 定义抽象类的接口。 维护一个指向Implementor类型对象的指针。 2.RefinedAbstraction 扩充

38、由Abstraction定义的接口。 3.Implementor 定义实现类的接口，该接口不一定要与Abstraction的接口完全一致。 事实上这两个接口可以完全不同。 一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。 4.ConcreteImplementor 实现Implementor接口并定义它的具体实现。类图 1.2.3 组合模式（Composite） 将对象组合成树形结构以表示部分-整体的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。适用性 1.你想表示对象的部分-整体层次结构。 2.

39、你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。参与者 1.Component 为组合中的对象声明接口。 在适当的情况下，实现所有类共有接口的缺省行为。 声明一个接口用于访问和管理Component的子组件。 (可选)在递归结构中定义一个接口，用于访问一个父部件，并在合*的情况下实现它。 2.Leaf 在组合中表示叶节点对象，叶节点没有子节点。 在组合中定义节点对象的行为。 3.Composite 定义有子部件的*些部件的行为。 存储子部件。 在Component接口中实现与子部件有*的操作。 4.Client 通过Component接口操纵组合部件的对象。类图（

40、另外找的）例子Component public abstract class 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(Employer employer); public List employers; public void printInfo(

41、) System.out.println(name); public List getEmployers() return this.employers; Leaf public class Programmer extends Employer public Programmer(String name) setName(name); employers = null;/程序员, 表示没有下属了 public void add(Employer employer) public void delete(Employer employer) public class ProjectAssist

42、ant extends Employer public ProjectAssistant(String name) setName(name); employers = null;/项目助理, 表示没有下属了 public void add(Employer employer) public void delete(Employer employer) Composite public class ProjectManager extends Employer public ProjectManager(String name) setName(name); employers = new A

43、rrayList(); 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 = new ProjectAssistant(项目助理); Employer programme

44、r1 = new Programmer(程序员一); Employer programmer2 = new Programmer(程序员二); pm.add(pa);/为项目经理添加项目助理 pm.add(programmer2);/为项目经理添加程序员 List ems = pm.getEmployers(); for (Employer em : ems) System.out.println(em.getName(); result 项目助理程序员二形象比喻：COMPOSITEMary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙

45、子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。 ”“”，MM都会用Composite模式了，你会了没有？ 合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。 1.2.4 装饰模式（Decorator） 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。适用性1.在不影响其他对象

46、的情况下，以动态、透明的方式给单个对象添加职责。 2.处理那些可以撤销的职责。 3.当不能采用生成子类的方法进行扩充时。参与者 1.Component 抽象构件角色: 定义一个对象接口，可以给这些对象动态地添加职责。 2.ConcreteComponent 具体构件角色: 定义一个对象，可以给这个对象添加一些职责。 3.Decorator 持有一个Component对象的实例，并定义一个与Component接口一致的接口。 4.ConcreteDecorator 向组件添加职责。类图例子Component public interface Person void eat();ConcreteC

47、omponent public class Man implements Person public void eat() System.out.println(男人在吃);Decorator public abstract class Decorator implements Person protected Person person; public void setPerson(Person person) this.person = person; public void eat() person.eat(); ConcreteDec*rator public class ManDec

48、oratorA extends Decorator public void eat() super.eat(); reEat(); System.out.println(ManDecoratorA类); public void reEat() System.out.println(再吃一顿饭); public class ManDecoratorB extends Decorator public void eat() super.eat(); System.out.println(=); System.out.println(ManDecoratorB类); Test public clas

49、s Test public static void main(String args) Man man = new Man(); ManDecoratorA md1 = new ManDecoratorA(); ManDecoratorB md2 = new ManDecoratorB(); md1.setPerson(man); md2.setPerson(md1); md2.eat(); result 男人在吃再吃一顿饭ManDecoratorA类=ManDecoratorB类1.2.5 外观模式（Facade） 为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，

50、这个接口使得这一子系统更加容易使用。适用性 1.当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。 2.客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。 3.当你需要构建一个层次结构的子系统时，使用fa

51、cade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。参与者 1.Facade 知道哪些子系统类负责处理请求。 将客户的请求代理给适当的子系统对象。 2.Subsystemclasses 实现子系统的功能。 处理由Facade对象指派的任务。 没有facade的任何相关信息；即没有指向Facade的指针。类图例子Facade public class Facade ServiceA sa; ServiceB sb; ServiceC sc; public Facade() sa = new ServiceAImpl(); sb = new ServiceBImpl(); sc = new ServiceCImpl(); public void methodA() sa.methodA(); sb.methodB();