Java23种设计模式

PAGEJava设计模式Java设计模式PAGE6目录TOC\o"1-3"\h\z\uHYPERLINK\l"_Toc266729529"1.设计模式PAGEREF_Toc266729529\h3HYPERLINK\l"_Toc266729530"1.1创建型模式PAGEREF_Toc266729530\h4HYPERLINK\l"_Toc266729531"1.1.1工厂方法PAGEREF_Toc266729531\h4HYPERLINK\l"_Toc266729532"1.1.2抽象工厂PAGEREF_Toc266729532\h6HYPERLINK\l"_Toc266729533"1.1.3建造者模式PAGEREF_Toc266729533\h10HYPERLINK\l"_Toc266729534"1.1.4单态模式PAGEREF_Toc266729534\h13HYPERLINK\l"_Toc266729535"1.1.5原型模式PAGEREF_Toc266729535\h15HYPERLINK\l"_Toc266729536"1.2结构型模式PAGEREF_Toc266729536\h17HYPERLINK\l"_Toc266729537"1.2.1适配器模式PAGEREF_Toc266729537\h17HYPERLINK\l"_Toc266729538"1.2.2桥接模式PAGEREF_Toc266729538\h19HYPERLINK\l"_Toc266729539"1.2.3组合模式PAGEREF_Toc266729539\h23HYPERLINK\l"_Toc266729540"1.2.4装饰模式PAGEREF_Toc266729540\h26HYPERLINK\l"_Toc266729541"1.2.5外观模式PAGEREF_Toc266729541\h29HYPERLINK\l"_Toc266729542"1.2.6享元模式PAGEREF_Toc266729542\h32HYPERLINK\l"_Toc266729543"1.2.7代理模式PAGEREF_Toc266729543\h34HYPERLINK\l"_Toc266729544"1.3行为型模式PAGEREF_Toc266729544\h37HYPERLINK\l"_Toc266729545"1.3.1责任链模式PAGEREF_Toc266729545\h37HYPERLINK\l"_Toc266729546"1.3.2命令模式PAGEREF_Toc266729546\h40HYPERLINK\l"_Toc266729547"1.3.3解释器模式PAGEREF_Toc266729547\h43HYPERLINK\l"_Toc266729548"1.3.4迭代器模式PAGEREF_Toc266729548\h45HYPERLINK\l"_Toc266729549"1.3.5中介者模式PAGEREF_Toc266729549\h49HYPERLINK\l"_Toc266729550"1.3.6备忘录模式PAGEREF_Toc266729550\h52HYPERLINK\l"_Toc266729551"1.3.7观察者模式PAGEREF_Toc266729551\h54HYPERLINK\l"_Toc266729552"1.3.8状态模式PAGEREF_Toc266729552\h58HYPERLINK\l"_Toc266729553"1.3.9策略模式PAGEREF_Toc266729553\h61HYPERLINK\l"_Toc266729554"1.3.10模板方法PAGEREF_Toc266729554\h63HYPERLINK\l"_Toc266729555"1.3.11访问者模式PAGEREF_Toc266729555\h651.设计模式(超级详细)内容简介有感于设计模式在日常开发中的重要性，同时笔者也自觉对设计模式小有心得，故笔者*写二十三种设计模式的简单例子、并整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式（HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂J*va联盟版），希望对大家有所帮助。本份帮助文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模*的组成部分，并附带有简单的例子和类*，目的是为了让读*了解二十三种*计模式，并能方便的查阅各种设计模*的用法及注意点。所附的例子非常简单，慢慢的引导读者从浅到深了解设计模式，并能从中享受设计的乐趣。由于每个人对设计*式的理解都不尽一致，因此，可能本文档的例子*有不恰当的地方，还望各位读者指出不恰当的地方。欢迎登录HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂J*va联盟进行技术交流，HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂Java联盟的论坛宗旨是：所有的技术发帖，均有回复。HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂Java联盟网址：HYPERLINK"http://www.crazyit.org"\t"_blank"http://www.crazyit.org笔者简介笔者曾师从李刚老师学习Java，现居广州。对Java软件开发、各种Java开源技术都非常感兴趣，曾参与开发、主持*发过大量Java、JavaEE项目，对Java、Java*E项目有一定认识*见解。欢迎大家与笔者就Java、JavaEE相*方面进行技术交流。笔者现为HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂Jav*联盟的总版主（论坛ID：杨恩雄），也希望通过该平台与大家分享Java、JavaEE技术、*得。本人邮箱：HYPERLINK"mailto:yangenxiong@163.com"yangenxiong@163.com声明本文档编写、制作过程中得到了HYPERLINK"http://www.crazyit.org"\t"_blank"疯狂Java联盟、以及笔者学习工作过程大量朋友的支持，大家都抱着一个目的：为国内软件软件开发事业作出绵薄贡献。我们在此郑重宣布，本*档遵循Apache2.0 协议 离婚协议模板下载合伙人协议 下载渠道分销协议免费下载敬业协议下载授课协议下载 。在完整保留全部文本(包括本版权页)，并且不违反Apache2.0协议的前提下，允许和鼓励任何人进行全文转载及推广，我们放弃除署名权外的一切权利。1.1创建型模式AbstractFactory(抽象工厂)FactoryMethod(工厂方法)Singleton(单态模式)Builder(建造者模式)Protot*pe*原型模式)1.1.1工厂方法定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。 适用性1.当一个类不知道它所必须创建的对象的类的时候。2.当一个类希望由它的子类来指定它所创建的对象的时候。3.当*将创建对象的职责委托给多个帮助*类中的某一个，并且*希望将哪一个帮助子类是代理者这一信息局部化的时候。 参与者1.Product定义工厂方法所创建的对象的接口。2.ConcreteProduct实现Product接口。3.Creator声明工厂方法，该方法返回一个Product类型的对象*Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。可以调用工厂方法以创建一个Product对象。4.ConcreteCreator重定义工厂方法以返回一个ConcreteProduct实例。 类图 例子*roductpublicinterfaceWork{voiddoWork();}ConcreteProductpublicclassStudentWorkimplementsWork{publicvoiddoWork(){System.out.println("学生*作业!");}}publicclassTeacherWorkimplementsWork{publicvoiddoWork(){System.out.println("老师审批作业!");}}CreatorpublicinterfaceIWorkFactory{Workget*ork();}Concre*eCreatorpu*licclassStudentWorkFactoryimplementsIWorkFactory{publicWorkgetWork(){*eturnnewStudentWork();}}publicclassTeacherWorkFactoryimplementsIWorkFactory{publicWorkgetWork(){returnnewTeacherWork();}}TestpublicclassTest{publicstaticvoidm*in(Strin*[]args){IWorkFactorystudentWorkFactory=newStudentWorkFactory();studentWorkFactory.getWork().d*Work();IWorkFactoryteacherWorkFactory*newTeacherWorkFactory();teacherWorkFactory.g*tWork().*oWork();}}result学生做作业!老师审批作业!1.1.2抽象工厂提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 适用性1.一个系统要独立于它的*品的创建、组合和 表 关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf 示时。2.一个系统要由多个产品系列中的一个来配置时。3.当你要强调一系列相关的产品对象的设计以便进行联合使用时*4*当你提供一个产品类库，而只想显示它们*接口而不是实现时。 参与者1.Ab*tractFactory声明一个创建抽象产品对象的操作接口。2.ConcreteFactory实现创建具体产品对象的操作。*.AbstractProduct为一类产品对象声明一个接口。4.ConcreteProdu*t定义一个将被相应的具体工厂创建的产品*象。实现*bstractProduct接口。5.Client仅使用由AbstractFactory和AbstractProduc*类声明的接口 类图 例子*bstractFactorypublicinterfaceIAn*malFactory{ICatcreateCat();IDogcreateDog();}ConcreteFactoryp*blicclassBlackAnimalFactoryimplem*ntsIAnimalFactory{publicICatcreateCat(){retur*newBlackCat();}publicIDogcreateDog(){returnnewBlackDog();}}publicclassWhiteAnimalFac*oryimp*ementsIAnimalFactory{publicICatcreateCat(){returnnewWhiteCat();}publicIDogcre*teDog(){returnnewWhiteDog();}}Abstrac*ProductpublicinterfaceICat{voideat();}publicinterfaceIDog{voideat();}Concrete*roductpublicclassBlack*atimplementsICat{publicvoideat(){System.out.println("Thebl*ckcatiseating!");}}publicclassWhiteCatimplements*Cat{publicvoideat(){Sy*tem.out.prin*ln("Thew*itecatiseating!*);}}publicclassBlackDogimplementsIDog{publicvoideat(){System.out.println("Theblackdogiseating");}}publicclassWhiteDogimplementsIDog{publicvoideat(){System.out.println("Thewhitedogiseat*ng!");}}Clientpublicstaticvoidmain(String[]args){IAnimalFactoryblackAnimalFa*tory=newBlackAnimalFactory();ICatblackCat=blackAnimalFactory.createCat();blackCat.eat();IDogblackD*g=blackAnimalFactory.createDog();blackDog.eat();IAnimalFactorywhiteAnimalF*ctory=newWhiteAnimalFactory();ICatwhiteCat=whiteAnimalFactory.createCat();whiteCat.eat();IDog*hiteDog=whiteAnimalFactory.createDog();whiteDog.eat();}res*ltThebla*kcatiseating!Th*blackdogiseatin*!Thewhitecatiseating!Thewhitedogis*ating!1.1.3建造者模式将一个复杂对象的构*与它的表示分离，使*同样的构建过程可以创建不同的表示。 适用性1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。*.当构造过程必须允*被构造的对象有不同*表示时。 参与者1.Builder为创建一个Product对象的各个部件指定抽象接口。2.ConcreteBuilder实现Buil*er的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示*提供一个检索产品的接口。3.Director构造一个使用Builder接口的对象。4.Product表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。包含定义组成部件的类，包括将这些部件装配成最终产品的接口。 类图 例子Buil*erpublicinterfacePersonBuilder{voidbuildHead();v*idbuildBody();voidbuildFoot()*PersonbuildPerson();}ConcreteBuilderpublicclassManBuilderimplementsPersonB*ilder{Personperson;publicManBuilder(){person=ne*Man();}publ*cvoidbuild*ody(){perso*.setBody("建造男人的身体");}publicvoidbuildFoot(){person.setFo*t("建造男人的脚");}publicvoidbuildHead(){pers*n.setHead("建造*人的头");}*ublicPersonbuildPerson(){retur*person;}}Dir*ctorpublicclassPersonDirec*or{publicPersonconstructPerson(PersonBuilderpb){pb.buildHead();pb.buildBody();pb.buildFoot();returnpb.buildPerson();}}ProductpublicclassPerson{privateStringhead;privateStringbody;privateStringfoot;publicStringgetH*ad(){returnhead;}publicvoidsetHead(Stringhea*){this.head=head;}publicStringgetBody(){returnbody;}publicvoidsetBody(Stringbody){this.b*dy=body;}publicStringgetFoot(){returnfoot;}publicvoidsetFoot(Stringfoot){t*is.foot=foot;}}publicclassManextendsPerson{}Testpubl*cclassTest{publicstaticvoidmain(String[]ar*s){PersonDirectorpd=newPersonDirector();Personperson=pd.constructPerson(newManBuilder());System*out.println(person.getBody());System.out.println(person.getFoot());System.out.println(person.getHead());}}result建造男人*身体建造男*的脚建造男人的头1.1.4单态模式保证一个类仅有一个实例，*提供一个访问它的全局访*点。 适用性1.当类只能有一个*例而且客户可以从一个众所周知的访问点访问它时。2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。 参与者Singleton定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。可能负*创建它自己的唯一实例。 类图 例子SingletonpublicclassSingleton{privatestaticSingletonsing;privateSingleton(){}publicst*ticSingletonget*nstance(){if(sing==null){sing=newSingleto*();}returnsing;}}TestpublicclassTest{publicstaticvoid*ain(*tring[]args){Singletonsing=Singleton.getInstance();Singletonsi*g2=Singleton.getI*stance();System.out.println(sing);System.out.pr*ntln(sing2);}}resultsingleton.Singleton@1c78e57singleton.Singleton@1c78e571.1.5原型模式用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 适用性1.当一个系统应该独立于它的产品创*、构成和表示时。2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。3.为了避免创建一个与产品类层次平行的工厂*层次时。4.当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。 参与者1.Prototype声明一个克隆自身的接口。2.ConcretePrototype实现一个克隆自身的操作。3.Client让一个原型克*自身从而创建一个新的对象。 类图 例子PrototypepublicclassPrototypeimplementsCloneable{privateStringname;publicvoidsetName(Stringname){this.name=name;}publicStringgetName(){returnthis.name;}publicObjectclone(){try{returnsuper.clone();}catch(Exceptione){e.printStackTrace();returnnull;}}}ConcretePrototypepubl*cclassConcretePrototypeextend*Prototype{publicConcretePrototype(Stringname){setName(name);}}Clientpublicclas*Test{publicstaticvoidmain(String[]args){Prototypepro=newConcretePrototy*e("prototype");Prototypepro2=(Prototype)pro.clone();*ystem.out.println(pro.getName()*;System.out.println(pro2.getName());}}resultprototypeprototype1.2结构型模式Adapter*适配器模式*Bridge(桥接模*)Composite(组合模式)Decorator(装*模式)Facade(外观模式)Flyweight(享元模式)Proxy(代理模式)1.2.1适配器模式将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口*兼容而不能一起工作的那*类可以一起工作。 适用性1.你想使*一个已经存在的类，而它的接口不符合你的需求。2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那*接口可能不一定兼容的类）协同工作。*.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。 参与者1.Target定义Client使用的与特定领域相关的接口。2.Client与符合Target接口的对象协同。3.Adapt*e定义一个已经存在的接口，这个接口需要适配。4.Adapter对Adaptee的接口与Target接口进行适配 类图 例子TargetpublicinterfaceTarget{voidadapteeMethod();voidadapterMethod();}AdapteepublicclassAdaptee{publicvoidadapteeMethod(){Syste*.out.p*intln("Adapteemethod!");}}Adapt*rpublicclas*Adapterimplement*Target{privateAdap*eeadaptee;publicAdapter(Adapteeadaptee){this.adapte*=adaptee;}publicvoidadapteeMethod(){adaptee.adapteeMethod();}publicvoidadapterMethod(){*ystem.out.println("Adaptermethod!");}}Clientpubliccla*sTest{publicstati*voidmain(String[]args){Targettarget=newAdapter(newAdaptee());tar*et.adapteeMethod();target.adapterM*thod();}}resultAdapteemethod!Adaptermethod!1.2.2桥接模式将抽象部分与它*实现部分分离，使它们都可以独立地变化。 适用性1.你不希望在抽*和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以*选择或者切换。2.类的抽象以及它的实现都应该可以通*生成子类的方法加以扩充。这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。4.正如在意图一节的第一个类图中所示的那样，有许多类要生成。这*一种类层次结构说明你必须将一个对象分解成两个部分。5.*想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知*这一点。 参与者1.Abstraction定义抽象类的接口。维护一个指向Implementor类型对象的指针。2.RefinedAbstraction扩充由Abstraction定义的接口。3.Implementor定义实现类的接口，该接口不一定要与Ab*traction的接口完全一致。事实上这两个接口可以完全不同。*般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。4.ConcreteImplementor*现Implementor接口并定义它的具体实现。 类图 例子Abstr*ctionpublicabstractclassPerson{privateClothingclothing;pr*vateStringtype;publicClothinggetClothing(){returnclothing;}publi*voidsetClothing(){this.clothing=*lothingFactory.getClothing();}publicvoidsetType(Stringtype){t*is.type=type;}publicStringgetType(){returnthis.ty*e;}publicabstractvoiddress();}RefinedAbstractionpublicclassManextends*erson{publicMan(){setType("男人");}publicvoiddress(){Clothingclothing=get*lothing();clothing.personDressCloth(this);}}publicclassLadyextendsPerson{publicLady(){setTyp*("女人");}publicvoiddress(){Cloth*ngclothing=getClothing();c*othing.personDressCloth(this);}}Implemento*publicabstractclassClothing{publicabstractvoidpersonDressC*oth(*ersonperson);}ConcreteImplemento*publicclass*ack*textendsClothing{publicvoidpersonDressCloth(Personperson){System.out.println(person.getType()+"穿马甲");}}publiccl*ssTrouserextendsClothing{publicvoidpersonDressCloth(Personperson){System.ou*.println(*erson.getType()+"穿裤子");}}TestpublicclassTe*t{publics*aticvoidmain(String[]args){Personman=newMan();Personlady=newLady();Clothingjacket=newJa*ket();Clot*ingtrouser=newTrouser();jacket.personDressCloth(man);trouser.personDressCloth(man);j*cket.personDressCloth(lady);trouser.personDressCloth(lady);}}result男人穿马甲男人穿裤子女人穿马甲女人穿裤子1.2.3组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。"Composite使得用户对单个对象和组合对*的使用具有一致性。" 适用性1.你想表示对象的部分-整*层次结构。2.你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。 参与者1.Component为组合中的对象声明接口。在适当的情况下，实现所有类共有接口的缺省行为。声明一个接口用于访问和管理Component的子组件。(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合*的情况下实现它。2.Leaf在组合中表示叶节点对象，叶节点没有子节点。在组合中定义节点对象的行为。3.Compos*te定义有子部件的*些部件的行为。存储子部件。在Component接口中实现与子部件有*的操作。4.Client通过Component接*操纵组合部件的对象。 类图 例子Componentp*blicabstractclassEmployer{privateStringname;publicvoidsetName(Stringname){this.name=*ame;}publicStringgetName(){returnthis.name;}publicabstractvoidadd(Employeremployer*;publicabstractvoiddelete(Employeremployer);publicListemployers;publicvoidprintInfo*){System.out.println(name);}*ublicListgetE*ployers(){returnthis.employers;}}LeafpublicclassProgrammerextendsEmployer{publicProgrammer(Stringname){setNam*(name);employers=null;//程序员,表示没有下属了}publicv*idadd(Employeremployer){}publicvoiddelete(Employeremployer){}}publicclassPro*ectAssistantextendsEmployer{publicProjectAss*stant(Stringname){setName(name);employers=*ull;//项目助理,表示没有下属了}publicvoidadd(Employeremployer){}publicvoiddelet*(Employeremployer){}}CompositepublicclassProject*anagerextendsE*ployer{publicProjectManager(Stringname){setName(name);employers=newA*rayList();}publicvoidadd(Employeremployer){employers.add(employer);}publicvoiddelete(Emplo*eremployer){employers.remove(employer);}}Clie*tpubl*cclassTest{publicst*ticvoidmain(String[]args){Employerpm=newProjectManager("项目经理");Emplo*erpa=newProjectAssistant("项目助理");Employerprogra*mer1=newProgrammer("程序员一");Employerprogrammer2=newProgrammer("程序员二");pm.add(pa);//为项目经理添加项目助理pm.add(programmer2);//*项目经理*加程序员Listems=pm.getEm*loyers();for(Employerem:ems){System.out.println(em.getNam*());}*}result项目助理程序员二1.2.4装饰模式动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模*相比生成子类更为*活。 适用性1.在不影响其他*象的情况下，以动态、透明的方式给单个对象添加职责。2.处理那些可以撤消的职责。3.当不能采用生成子类的方法进行扩充时。 参与者1.Component定义一个对象接口，可以给这些对象动态地添加职责。2.ConcreteComponent定义一个对象，可以给这个对象添加一些职责。3.Decorator维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。4.ConcreteDecorator向组件添加职责。 类图 例子ComponentpublicinterfacePerson{voideat();}ConcreteComponent*ublicclassM*nimplementsPerson{publicvoideat(){System.out.println("男人在吃");*}Decoratorpublicabstrac*classDecoratorimplementsPerso*{protectedPersonperson*publicvoidsetPerson(Personperson){this.person=person;}publicvoideat(){person.eat();}}ConcreteDec*ratorpubli*classManDecoratorAextendsDecorator{publicvoideat(){super.eat();reEat();Sy*tem.out.println("ManDecoratorA类");}publicvoidreEat(){System.out.println("再吃一顿饭");*}publicclassManDecoratorBextendsDecorator*publicvoideat(){super.eat();Syst*m.out.println("===============");System.out.println("ManDecoratorB类");}}TestpublicclassTest{publicst*ticvoidmain(Strin*[]args){Manman=newMan();ManDecoratorAmd1=newManDecoratorA();ManDecoratorBmd2=n*wManDecoratorB();md1.setPerson(man);md2.setPerson(md1);md2.eat();}}result男人在吃再吃一顿饭ManDecoratorA类===============ManDecoratorB类1.2.5外观模式为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这*子系统更加容易使用。 适用性1.当你要为一个*杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给*些不需要定制子系统的用户带来一些使用上的困难。Fa*ade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足*，而那些需要更多的可定制性的用户可以越过facade层。2.客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。3.当你需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。 参与者1.Facade知道哪些子系统类负责处理请求。将客户的请求代理给适当的子系统对象。2.Subsystemclasses实现子系统的功能。处理由Facade对象指派的任务。没有facade的任何相关信息；即没有指向*acade的指针。 类图 例子Facadepubli*classFacade{ServiceAs*;ServiceBsb;ServiceCsc;publicFacade(){sa=newS*rviceAImpl();sb=new*erviceBImpl();sc=newServiceCImpl();}publicvoidmethodA(){sa.methodA();sb.methodB();}publi*voidmethodB(){s*.methodB();sc.methodC();}publicvoidmethodC(){sc.methodC();sa.methodA();}}Subsystemclasse*public*lassServiceAImplimplementsServiceA{publicvoidmethodA(){System.out.println("这是服务A");}}publicclassServiceBImplimplementsServiceB{publicvoidmethodB(){System.out.println("这是服务B");*}publicclassServiceCImplimplementsServiceC{publicvoidmethodC(){System.out.println("这是服*C");}}TestpublicclassTest{publicstaticvoi*main(String[]args){ServiceAsa=newServiceAImpl();Ser*iceBsb=newServiceBImpl();sa.metho*A();sb.methodB();System.out.println("========");//facadeFacadefacade=newFacade();facade.methodA();facade.methodB();}}resu*t这是服务A这是*务B========这是服务A这是服务B这是服务B这是服务C1.2.6享元模式运用共享技术有效地支持大量细粒度的对象。 适用性当都具备下列情况时，使用Flyweight模式：1.一个应用程序使用了大量的*象。2.完全由于使用大量的对象，造成很大的存储开销。3.对象*大多数状态都可变为外部状态。4.如果删除对象的外部状态，那么可以*相对较少的共享对象取代很多组对象。5.应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于*念上明显有别的对象，标识测试将返回真值。 参与者1.Flyweight描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。2.ConcreteFlyweight实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。Concrete*lyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。3.UnsharedConcreteFlyweigh*并非所有的Flywe*ght子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共*。在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。4.Flyweigh*Factory创建并管理flywe*ght对象。确保合理地共享flyweight。当用户请求一个flywei*ht时，Fl*weightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。 类* 例子Flyweightpublicint*rfaceFlyweight{voida*tion(intarg);}ConcreteFlyweightpublicclassFlyweightImplimplementsFlyweight{publicvoidaction(intarg){//T*DOAuto-genera*edmethodstubSystem.out.println(*参数值:"+arg);}}FlyweightFactorypublicclassFlyweigh*Factory{privatestaticMapflyweights=newHashMap();publicFlyweightF*ctory(Stringarg){flyweights.put(arg,newFlyweightImpl());}publicstaticFlyweightgetFly*eight(Stringkey){if(flyweights.get(key)==null){flyweights.p*t(key,newFlyweightImpl());}returnflyweights.get(key);}publicstaticintg*tSize(){retu*nflyweights.size();}}TestpublicclassTest{publicstaticv*idmain(String[]args){//TODOAuto-generatedmethodstubFlyweightfly1=Flyw*ightFact*ry.getFlyweight(*a");fly1.action(1);Flyweightfly*=FlyweightFactory.getF*yweight("a");System.out.println(fly1==fly2);Flyweightfl*3=FlyweightFactory.getFlywei*ht("b");fly3.action(2);Flyweightfly4=Flyweigh*Factory.getF*yweight("c");fly4.action(3);Flyweigh*fly5=FlyweightFactory.getFlyweight("d");fly4.action(4);System.out.println(FlyweightFactory.getSize())*}}result参数值:1true参数值:2*数值:3参数值:441.2.7代理模式为其他对象提供一种代理以控制对这个对象的访问。 适用性1.远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。2.虚*理（VirtualProxy）根据需*创建开销很大的对象。3.保护代理（ProtectionProxy）控制对原始对象的访问。4.智能指引（SmartReference）取代了简单的指针，它在访问对象时执行一些附加操作。 参与者1.Proxy保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。*供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。控制对实体的*取，并可能负责创建和删除它。其他功能依赖于*理的类型：2.RemoteProxy负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求。*.VirtualProxy可以缓存实体的附加信息，以便延迟对它的访问。4.ProtectionProxy检查调用者是*具有实现一个请求所必需的访问权限。5.Subjec*定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都*以使用Proxy。6.RealSubject*义Proxy所代表的实体。 类图 例子ProxypublicclassProxyObjectimplementsObject{Objec*obj;publicProxyObject(){System.out.println("这是代理类");o*j=newObjectImpl();}publicvoidac*ion(){System.out.p*intln("代理开始");obj.action*);System.out.println(*代理结束");}}SubjectpublicinterfaceObje*t{voidaction();}RealSubjectpublicclassObjectImplimplementsObject{pu*licvoidaction(){System.out.println("========");System.out.println("========");System.out.pr*ntln("这是被代理的类");System.out.println("========");System.out.println("========");}}TestpublicclassTest{publi*staticvoidmain(){Objectob*=newProxyObject();obj.action();*}result这是代理类代理开始=========*======这是被代理的类==============*=代理结束1.3行为型模式ChainofResponsibility(责任链模式)Command(命令模式)Interpreter(解释器模式)Iterator(迭代器*式)Mediator(中介者模式)Memento(备忘录模式)Observer(观察者模式)State(状*模式)Strategy(策略模式)TemplateMethod(模板方法)Vis*tor(访问者模式)1.3.1责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一*链，并*着这条链传递该请求，直到有一个对象处理它为止。这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者. 适用性1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。2.你*在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。3.可处理一个请求的对象集合应被动态指定。 参与者1.Handler定义一个处理请求的接口。（可选）实现后继链。2.ConcreteHandler处理它所负责的请*。可访问它的后继者。如果可处理该*求，就处理*；否则将该请求转发给它的后继者。3.Client向链上的具体处理者(ConcreteHandler)对象提交请求。 类图 例子Hand*erpublicinterfaceRequestHandle{voidhandleRequest(R*questrequest);}ConcreteHandlerpublicclassHRRequestHandleimplementsRequestHandle{publicvoidhandleRequest(Requestrequest){if(requestinstanceofDimissionRequest){System.out.println("要离职,人事审批!");}System.out.println("请求完*");}}publicclassPMRequestHandleimplementsRequestHandle{Req*estHandlerh;publicPMRequestHandle(RequestHandle*h){this.rh=rh;}publicvoidhandle*equest(Requestrequest){if(requestinstanceofAddMoneyRequest){System.out.println("要加薪,项目经理审批!*);}else{rh.handleRequest(request);}}}publicclassTLRequestHandleim