java设计模式和应用场景.docx

1、java设计模式和应用场景Java常见设计模式应用场景1、抽象工厂应用场景：封装变化点。创建一系列相互依赖的对象。在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作;同时由于需求的变化，往往存在更多系列对象的创建工作。如何应对这各变化如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合。public abstract Class AbstractFactory/创建一系列相互关联的对象如游戏场景中相互关联的Road,Building,Tunnel,Jungle对象public abstract ProductA createP

2、roductA();public abstract ProductB createProductB();/./多系列体现在ConcreteFactoryA,ConcreteFactoryB这些具体工厂创建该系列下的多个相互关联的对象public class ConcreteFactoryA extends AbstractFactory/具体创建ProductA,ProductB的哪个子类再这里指定,如/这里相互关联的对象体现在ProductA1和ProductB1够成第一种风格public ProductA createProductA()return new ProductA1();ret

3、urn new ProductB1();public class ConcreteFactoryB extends AbstractFactory/具体创建ProductA,ProductB的哪个子类再这里指定,如public ProductA createProductA()return new ProductA2();return new ProductB2();public abstract class ProductA/其子类是ProductA1,ProductA2/定义一些接口;public void someMethod();/.public abstarct class Prod

4、uctB/其子类是ProductB1,ProductB2/定义一些接口;public void someMethod();/.public class TestProductA a;ProductB b;public static void main(String args)/客户端要创建不同风格的游戏场景(多系列)AbstractFactory factory = new ConcreteFactoryA();ProductA a = factory.createProductA();ProductB b = factory.createProductB();play();/创建另一种风格的

5、游戏场景,只须更改ConcreteFactoryB();/AbstractFactory factory = new ConcreteFactoryA();/ProductA a = factory.createProductA();/ProductB b = factory.createProductB();/play();public static void play()a.someMethod();b.someMethod();2、Builder在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成;由于需求的变化，这个复杂对象的各个部分经常面临着

6、剧烈的变化，但是将它们组合在一起的算法却相对稳定。Builder设计模式是应对这样的需求变化：如何提供一种“封装机制”来隔离“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”，不随着需求改变而改变。/抽象定义如何构建Product及其子对象public abstract class Builder/获取整体对象public abstract Product getProduct();/构建部分对象public abstract void buildProductA();public abstract void buildProductB();public abstract void

7、 buildProductC();/具体构建Product对象public class ConcreteBuilder extends Builder/复杂对象是由其他子对象组合而成,Houser是由ProductA,productB,productC的一个或者多个实例组合而成private Product product;private List productAList = new ArrayList();private List productBList = new ArrayList();private List productCList = new ArrayList();/返回该复

8、杂对象public Product getProduct()product.setProductAList(this.productAList);product.setProductBList(this.productBList);product.setProductCList(this.productCList);return this.product;/构建ProductApublic void buildeProductA()this.productAList.add(new ProductAA();/this.productAList.add(new ProductAB();/构建Pr

9、oductBpublic void buildeProductB()this.productBList.add(new ProductBA();/this.productBList.add(new ProductBB();/构建ProductCpublic void buildeProductC()this.productCList.add(new ProductCA();/this.productCList.add(new ProductCB();/复杂对象是由其他子对象组合而成,包含ProductA,ProductB,ProductC的实例public abstract class Pro

10、duct private List ProductAList;private List productBList;private List productCList;/.public class Test/定义构建Product的稳定的算法,如构建1个ProductA,两个ProductB,三个ProductC/这个复杂对象面临剧烈的变化是指ProductA有子类ProductAA,ProductAB;ProductB有/子类ProductBA,ProductBB;ProductC有子类ProductCA,ProductCB,这些具体子类的构建/封装在具体的ConcreteBuilder里,客

11、户端只须修改ConcreteBuilder即可public static Product createProduct(Builder builder)/如第一步创建1个ProductAbuilder.createProductA();/第二步两个ProductBbuilder.createProductB();builder.createProductB();/第三步创建三个ProductCbuilder.createProductC();builder.createProductC();builder.createProductC();/最终才能获得Product对象return build

12、er.getProduct();public static void main(String args)Builder builder = new ConcreteBuilder();Product product = this.createProduct(builder);3、工厂方法(把变和不变的地方隔离出来)紧耦合和松耦合：如何进行模块划分？主模块(抽象部分)次模块(细节具体部分) 对模块进行分析(高层模块-低层模块)在软件系统中，经常面临着“某个对象”的创建工作;由于需求的变化，这个对象的具体实现经常面临着剧烈的变化，但是它却拥有比较稳定的接口。如何应对这种变化？如何提供一种“封装机制

13、”来隔离出“这种易变对象”的变化，从而保持系统中“其他依赖该对象的对象(主逻辑)”不随着需求改变而改变?解决：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟。public abstract Class Car/定义一系列稳定的接口public Class BMW extends Car/override cars methodpublic abstract Class AbstractFactory/只依赖于抽象Car，具体的Car延迟到具体的工厂中创建public Car createCar();public Class BMWFac

14、toryoverridepublic Car createCar()return new BMW();public Class Test/客户端程序只依赖抽象的Car和抽象的AbstractFactory/如果系统扩展其他车，只须修改这处的代码 = new BMWFactory();(当然可以放到配置文件中读取出来就不用改代码了)/另外加两个类public Class KaiYue extends Car,public Class KaiYueFactory extends AbstractFactoryAbstractFactory factory = new BMWFactory();Ca

15、r car = factory.createCar();4、Bridge模式适用场景:将抽象部分与实现部分分离,使他们都可以独立地变化将 或将一个事物的多个维度的变化分离,该模式证明聚合比继承好/最初的做法是将两个维度的抽象方法都集中在Abstraction中/两个维度扩展出的所有子类都继承Abstraction,冗余太多public abstraction class Abstractionpublic absracte void operate();public absracte void operationImpl();public class ConcreteAbstractionA

16、extends Abstractionpublic void operate() ;public void operationImpl() ;public class ConcreteAbstractionB extends Abstractionpublic void operate() ;public void operationImpl() ;public class ConcreteAbstractionConcreteImplementorA extends ConcreteAbstractionApublic void operate() ;public void operatio

17、nImpl() ;public class ConcreteAbstractionConcreteImplementorB extends ConcreteAbstractionApublic absracte void operate() ; public absracte void operationImpl() ;/./如果在多个维度上扩展,子类越来越多,实现代码有重复改进后的代码public abstract class Abstractionprotected Implemetor implementor;publlic Abstractor(Implementor implemen

18、tor)this.implementor = implementor;/定义一些其他抽象方法public abstract void operation();public class ConcreteAbstraction extends Abstractionpublic ConcreteAbstraction(Implementor implementor)super(implementor);public void operation() ;public abstract Implementorpublic abstract void operationImpl();public cla

19、ss ConcreteImplementorA extends Implementorpublic class ConcreteImplementorB extends Implementorpublic class Testpublic static void main(String args)Implementor implemetor = new ConcreteImplementorA();Abstraction abstraction = new ConcreteAbstraction(implementor);abstraction.operation();implementor.

20、operationImpl();5、适配器Adapter在软件系统中,由于应用 环境的变化,常常要将一些现在的对象放到新的环境中应用,但是新环境要求的接口是这些现存对象所不满足的适用场景:在不改变原来实现的基础上,将原来不兼容的接口转换为兼容的接口。将一个类的接口转换至客户希望的另一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。/新环境所使用的接口,或者说是客户端想使用的接口public abstract Targetpublic void request();/已经存在的specificRequest接口public class Adapteepubl

21、ic void specificRequest() public class Adapter extends Targetprivate Adaptee adaptee;public Adapter(Adaptee adaptee)this.adaptee = adaptee;public void request()/处理其它事项/适配到目标接口adaptee.specificRequest();/处理其它事项public class Clientpublic static void main(String args)Adapter adapter = new Adapter(new Ada

22、ptee();adapter.request();6、Decarator过度地使用了继承来扩展对象的功能,由于继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性并且随着子类的增多,各子类的组合会导致更多子类的膨胀.动态地给一个对象增加一些额外的职责public abstract class Component/定义一些抽象方法 public abstract void operation();public abstract class ConcreteComponentpublic abstract void operation()/.原有功能public abstract class De

23、coratorprivate Component component;private Decorator(Component component)ponent = component;/原有operation的功能public void operation()ponent.operation();/一个具体的Decorator就是扩展了Component类的operation();/如果在Component类中添加一个行为则需要用Visitor模式,定义一个预留的待扩充的接口,很类似public ConcreteDecoratorA extends Decoratorpublic Concre

24、teDecoratorA(Decorator decorator)super(decorator);public ConcreteDecoratorB extends Decoratorpublic ConcreteDecoratorB(Decorator decorator)super(decorator);public void operation()/扩展operation的功能/ Do some extensionotherMethod1();operation();public class Testpublic static void main(String args)Compone

25、nt component = new ConcreteComponent();Decorator decorator1 = new ConcreteDecoratorA();Decorator decorator2 = new ConcreteDecoratorB();public void operation()/扩展operation的功能otherMethod2();operation();7、Command命令模式对发送者和接收者完全解耦public abstract class Senderprivate Command command;public Sender(Command command)mand = command;/发送命令public abstract send(Command command);/命令调度者,发送什么样的命令以及通告谁执行命令public class CommandInvokerprivate Command commandA;private Command commandB;private Comm