JAVA设计模式之结构型模式.doc

《JAVA设计模式之结构型模式.doc》由会员分享，可在线阅读，更多相关《JAVA设计模式之结构型模式.doc（15页珍藏版）》请在沃文网上搜索。

1、JAVA设计模式之结构型模式结构型模式包括适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式共7类1、适配器模式将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适用条件：1）你想使用一个已经存在的类，而它的接口不符合你的需求。2）你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。3）（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。参与者：1）Target：定义

2、Client使用的与特定领域相关的接口。2）Client：与符合Target接口的对象协同。3）Adaptee：定义一个已经存在的接口，这个接口需要适配。4）Adapter：对Adaptee的接口与Target接口进行适配。示例：package zantip.modules;public class AdapterTest / 测试public static void main(String args) Target target = new Adapter(new Adaptee();target.adapteeMethod();target.adapterMethod();/ Target

3、interface Target void adapteeMethod();void adapterMethod();/ Adapteeclass Adaptee public void adapteeMethod() System.out.println(Adaptee Method);/ Adapterclass Adapter implements Target private Adaptee adaptee;public Adapter(Adaptee adaptee) this.adaptee = adaptee;Overridepublic void adapteeMethod()

4、 System.out.println(使用原来存在的接口方法);adaptee.adapteeMethod();Overridepublic void adapterMethod() System.out.println(使用新接口方法);System.out.println(Adapter Method);输出结果：使用原来存在的接口方法Adaptee Method使用新接口方法Adapter Method2、桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化。适用条件：1）你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以

5、选择或者切换。2）类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。3）对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。4）想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。参与者：1）Abstraction：定义抽象类的接口。维护一个指向Implementor类型对象的指针。2）RefinedAbstraction：扩充由Abstraction定义的接口。3）Implementor：定义实现类的接口，该接口不一定要与Abstraction的接口完全一致

6、。事实上这两个接口可以完全不同。一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。4）ConcreteImplementor：实现Implementor接口并定义它的具体实现。示例：package zantip.modules;public class BridgeTest / 测试public static void main(String args) People man1 = new Man1();People lady = new Lady();Clothing jacket = new Jacket();Clothi

7、ng trouser = new Trouser();jacket.personDressCloth(man1);trouser.personDressCloth(man1);jacket.personDressCloth(lady);trouser.personDressCloth(lady);/ Implementorabstract class Clothing public abstract void personDressCloth(People person);/ Abstractionabstract class People private Clothing clothing;

8、private String type;public Clothing getClothing() return clothing;public void setClothing(Clothing clothing) this.clothing = clothing;public String getType() return type;public void setType(String type) this.type = type;public abstract void dress();/ ConcreteImplementorclass Jacket extends Clothing

9、Overridepublic void personDressCloth(People person) System.out.println(person.getType() + 穿马甲);class Trouser extends Clothing Overridepublic void personDressCloth(People person) System.out.println(person.getType() + 穿裤子);/ RefinedAbstractionclass Man1 extends People public Man1() setType(男人);Overrid

10、epublic void dress() Clothing clothing = getClothing();clothing.personDressCloth(this);class Lady extends People public Lady() setType(女人);Overridepublic void dress() Clothing clothing = getClothing();clothing.personDressCloth(this);输出结果：男人穿马甲男人穿裤子女人穿马甲女人穿裤子3、组合模式将对象组合成树形结构以表示部分-整体的层次结构。”Composite”使

11、得用户对单个对象和组合对象的使用具有一致性。适用条件：1）你想表示对象的部分-整体层次结构。2）你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。参与者：1）Component：为组合中的对象声明接口。在适当的情况下，实现所有类共有接口的缺省行为。声明一个接口用于访问和管理Component的子组件。(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合*的情况下实现它。2）Leaf：在组合中表示叶节点对象，叶节点没有子节点。在组合中定义节点对象的行为。3）Composite：定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关

12、的操作。4）Client：通过Component接口操纵组合部件的对象。示例：package zantip.modules;import java.util.ArrayList;import java.util.List;public class CompositeTest / 测试public static void main(String args) Employer pm = new ProjectManager(项目经理);Employer pa = new ProjectAssistant(项目助理);Employer programer1 = new Programmer(北京程序

13、员);Employer programer2 = new Programmer(珠海程序员);pm.add(pa);pm.add(programer1);pm.add(programer2);List employers = pm.getEmployers();for (Employer item : employers) System.out.println(item.getName();/ Componentabstract class Employer private String name;public String getName() return name;public void

14、setName(String name) this.name = name;public abstract void add(Employer employer);public abstract void delete(Employer employer);public List employers;public List getEmployers() return employers;public void setEmployers(List employers) this.employers = employers;/ Leafclass Programmer extends Employ

15、er public Programmer(String name) setName(name);employers = null;/ 程序员Overridepublic void add(Employer employer) Overridepublic void delete(Employer employer) class ProjectAssistant extends Employer public ProjectAssistant(String name) setName(name);employers = null;/ 项目助理Overridepublic void add(Emp

16、loyer employer) / TODO Auto-generated method stubOverridepublic void delete(Employer employer) / TODO Auto-generated method stub/ Compositeclass ProjectManager extends Employer public ProjectManager(String name) setName(name);employers = new ArrayList();Overridepublic void add(Employer employer) emp

17、loyers.add(employer);Overridepublic void delete(Employer employer) employers.remove(employer);输出结果：项目助理北京程序员珠海程序员4、装饰模式动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。适用条件：1）在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。2）处理那些可以撤消的职责。3）当不能采用生成子类的方法进行扩充时。参与者：1）Component：定义一个对象接口，可以给这些对象动态地添加职责。2）ConcreteComponent：

18、定义一个对象，可以给这个对象添加一些职责。3）Decorator：维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。4）ConcreteDecorator：向组件添加职责。示例：package zantip.modules;public class DecoratorTest / 测试public static void main(String args) Man man = new Man();ManDecoratorA md1 = new ManDecoratorA();ManDecoratorB md2 = new ManDecoratorB();m

19、d1.setPerson(man);md2.setPerson(md1);md2.eat();/ Componentinterface Person public void eat();/ Concrete Componentclass Man implements Person Overridepublic void eat() System.out.println(男人在吃);/ Decoratorabstract class Decorator implements Person protected Person person;public Person getPerson() retu

20、rn person;public void setPerson(Person person) this.person = person;Overridepublic void eat() this.person.eat();/ Concrete Decoratorclass ManDecoratorA extends Decorator Overridepublic void eat() / TODO Auto-generated method stubsuper.eat();sleep();System.out.println(ManDecoratorA类);public void slee

21、p() System.out.println(吃完了，休息一会儿);class ManDecoratorB extends Decorator Overridepublic void eat() / TODO Auto-generated method stubsuper.eat();System.out.println(ManDecoratorB类);输出结果：男人在吃吃完了，休息一会儿ManDecoratorA类ManDecoratorB类5、外观模式为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这些子系统更加容易使用。适用条件：1）当你要为一个复

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

23、你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。参与者：1）Faade：知道哪些子系统类负责处理请求。将客户的请求代理给适当的子系统对象。2）Subsystemclasses：实现子系统的功能。处理由Facade对象指派的任务。没有facade的任何相关信息；即没有指向facade的指针。示例：package zantip.modules;public class FacadeTest / 测试public static void main(String args) ServiceA sa = new ServiceAImpl();ServiceB sb = new Se

24、rviceBImpl();ServiceC sc = new ServiceCImpl();sa.MethodA();sb.MethodB();sc.MethodC();System.out.println(=);/ facadeFacade facade = new Facade();facade.MethodA();facade.MethodB();interface ServiceA public void MethodA();interface ServiceB public void MethodB();interface ServiceC public void MethodC()

25、;/ subsystemclassesclass ServiceAImpl implements ServiceA Overridepublic void MethodA() System.out.println(这是A服务);class ServiceBImpl implements ServiceB Overridepublic void MethodB() System.out.println(这是B服务);class ServiceCImpl implements ServiceC Overridepublic void MethodC() System.out.println(这是C

26、服务);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();public void MethodB() sb.MethodB();sc.MethodC();public void MethodC() sc.MethodC();sa.MethodA();输出结果：这是A服务这是B服务

27、这是C服务=这是A服务这是B服务这是B服务这是C服务6、享元模式运用共享技术有效地支持大量细粒度的对象。适用条件：1）一个应用程序使用了大量的对象。2）完全由于使用大量的对象，造成很大的存储开销。3）对象大多数状态都可变为外部状态。4）如果删除对象的外部状态，那么可以相对较少的共享对象取代很多组对象。5）应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。参与者：1）Flyweight：描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。2）ConcreteFlyweight：实现Flyweight接口，并为内部状态（

28、如果有的话）增加存储空间。ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。3）UnsharedConcreteFlyweight：并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。4）FlyweightFactory：创建并管理flyweight对象。确保合理地共享flyweight。当用户请求一个f

29、lyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。示例：package zantip.modules;import java.util.HashMap;import java.util.Map;public class FlyweightTest / 测试public static void main(String args) Flyweight fly1 = FlyweightFactory.getFlyweight(aa);fly1.action(1);Flyweight fly2 = FlyweightFactory.getFly

30、weight(aa);System.out.println(fly1 = fly2);Flyweight fly3 = FlyweightFactory.getFlyweight(bb);fly3.action(10);Flyweight fly4 = FlyweightFactory.getFlyweight(cc);fly4.action(100);Flyweight fly5 = FlyweightFactory.getFlyweight(dd);fly5.action(1000);System.out.println(FlyweightFactory.getSize();/ Flywe

31、ightinterface Flyweight public void action(int arg);/ ConcreteFlyweightclass FlyweightImpl implements Flyweight Overridepublic void action(int arg) System.out.println(参数值： + arg);/ Flyweight Factoryclass FlyweightFactory private static Map flyweights = new HashMap();public FlyweightFactory(String ar

32、g) flyweights.put(arg, new FlyweightImpl();public static Flyweight getFlyweight(String key) if (flyweights.get(key) = null) flyweights.put(key, new FlyweightImpl();return flyweights.get(key);public static int getSize() return flyweights.size();输出结果：参数值：1true参数值：10参数值：100参数值：100047、代理模式为其他对象提供一种代理以控制

33、对这个对象的访问。适用条件：1）远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。2）虚拟代理（VirtualProxy）根据需要创建开销很大的对象。3）保护代理（ProtectionProxy）控制对原始对象的访问。4）智能指引（SmartReference）取代了简单的指针，它在访问对象时执行一些附加操作。参与者：1）Proxy：保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。控制对实体的存取，并可能负责创建和删除它。2）Rem

34、oteProxy：负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求。3）VirtualProxy：可以缓存实体的附加信息，以便延迟对它的访问。4）ProtectionProxy：检查调用者是否具有实现一个请求所必需的访问权限。5）Subject：定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。6）RealSubject：定义Proxy所代表的实体。示例：package zantip.modules;public class ProxyTest / 测试public static void main(Stri

35、ng args) Object obj = new ProxyObject();obj.action();/ proxyclass ProxyObject implements Object Object obj;public ProxyObject() System.out.println(这是代理类);obj = new ObjectImpl();public void action() System.out.println(代理开始);obj.action();System.out.println(代理结束);/ Subjectinterface Object public void action();/ RealSubjectclass ObjectImpl implements Object Overridepublic void action() System.out.println(开始工作);System.out.println(继续工作);System.out.println(这是被代理的类);System.out.println(=);输出结果：这是代理类代理开始开始工作继续工作这是被代理的类=代理结束