浅析java常用的设计模式

1、58/581、工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就能够接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、建筑模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建筑过程生成具有不同的内部表象的产品对象。建筑模式使得产品内部表象能够独立的变化，客户不必明白产品内部组成的细节。建筑模式能够强制实行一种分步骤进行的建筑过程。 3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被

2、实例化这种细节。 4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制那个原型对象的方法创建出更多同类型的对象。原始模型模式同意动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供那个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。 6、适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口缘故不匹配而无法一起工作的两个类能够一起工作。适配类能够依照参数返还一

3、个合适的实例给客户端。 7、桥梁模式：将抽象化与实现化脱耦，使得二者能够独立的变化，也确实是讲将他们之间的强关联变成弱关联，也确实是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者能够独立的变化。 8、合成模式：合成模式将对象组织到树结构中，能够用来描述整体与部分的关系。合成模式确实是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。 9、装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，

4、这些功能能够再动态的撤消。增加由一些差不多功能的排列组合而产生的特不大量的功能。 10、门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也确实是讲它是一个单例模式。但整个系统能够有多个门面类。 11、享元模式：FLYWEIGHT在拳击竞赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，可不能随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能阻碍内蕴状态，它们是相互独立的

5、。将能够共享的状态和不能够共享的状态从常规类中区分开来，将不能够共享的状态从类里剔除出去。客户端不能够直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。 12、代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象操纵对源对象的引用。代理确实是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象能够在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式能够并不明白真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被

6、代理对象必须有系统的其他角色代为创建并传入。 13、责任链模式：在责任链模式中，专门多对象由每一个对象对其下家的引用而接 起来形成一条链。请求在那个链上传递，直到链上的某一个对象决定处理此请求。客户并不明白链上的哪一个对象最终处理那个请求，系统能够在不阻碍客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求能够最终不被任何接收端对象所同意。 14、命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式同意请求的一方和发送的一方独立开来，使得请求的一方不必明白接收请求的一方的接口

7、，更不必明白请求是如何被接收，以及操作是否执行，何时被执行以及是如何被执行的。系统支持命令的撤消。 15、解释器模式：给定一个语言后，解释器模式能够定义出其文法的一种表示，并同时提供一个解释器。客户端能够使用那个解释器来解释那个语言中的句子。解释器模式将描述如何样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也确实是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合差不多上一个语言。 16、迭代子模式：迭代子模式

8、能够顺序访问一个聚拢中的元素而不必暴露聚拢的内部表象。多个对象聚在一起形成的总体称之为聚拢，聚拢对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚拢本身隔开。迭代子模式简化了聚拢的界面。每一个聚拢对象都能够有一个或一个以上的迭代子对象，每一个迭代子的迭代状态能够是彼此独立的。迭代算法能够独立于聚拢角色变化。 17、调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们能够松散偶合。当某些对象之间的作用发生改变时，可不能立即阻碍其他的一些对象之间的作用。保证这些作用能够彼此独立的变化。调停者模式将多对多的相互作用转化为

9、一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。 18、备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而能够在今后合适的时候把那个对象还原到存储起来的状态。 19、观看者模式：观看者模式定义了一种一队多的依靠关系，让多个观看者对象同时监听某一个主题对象。那个主题对象在状态上发生变化时，会通知所有观看者对象，使他们能够自动更新自己。 20、状态模式：状态模式同意一个对象在其内部状态改变的时候改变行为。那个对象看上去象是改变了它的类一

10、样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。 21、策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们能够相互替换。策略模式使得算法能够在不阻碍到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都可不能阻碍到环境和客户端。 22、模板

11、方法模式：模板方法模式预备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类能够以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。 23、访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，同意那个操作的数据结构能够保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合能够相对自由的演化。访问者模式使得增加新的操作变的专门容易，确实是增加一个新的访问者类。访问

12、者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象扫瞄逻辑放在访问者类中，而不是放到它的子类中。访问者模式能够跨过几个类的等级结构访问属于不同的等级结构的成员类。工厂模式的几种形态：1、简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式。 2、工厂方法模式，又称为多态性工厂(Polymorphic Factory)模式 3、抽象工厂模式，又称工具（Kit或ToolKit）模式 简单工厂模式（Simple Factory） 1、模式： 简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Fact

13、ory Method）模式。 它是由一个工厂对象决定创建出哪一种产品类的实例。 Java代码 1.2、举例： 2. /水果接口 3. public interface Fruit 4. void grow(); /生长 5. void harvest(); /收获 6. void plant(); /种植 7. 8. 9. /苹果类 10. public class Apple implements Fruit 11. private int treeAge /树龄 12. 13. public void grow() 14. log(Apple is growing.); 15. 16. 1

14、7. public void harvest() 18. log(Apple has been harvented.); 19. 20. 21. public void plant() 22. log(Apple has been planted.); 23. 24. 25. /辅助方法 26. public static void log(String msg) 27. System.out.println(msg); 28. 29. 30. public int getTreeAge() 31. return treeAge; 32. 33. 34. public void setTree

15、Age(int treeAge) 35. this.treeAge = treeAge; 36. 37. 38. 39. /葡萄类 40. public class Grape implements Fruit 41. private boolean seedless; 42. 43. public void grow() 44. log(Grape is growing.); 45. 46. 47. public void harvest() 48. log(Grape has been harvested.); 49. 50. 51. public void plant() 52. log

16、(Grape has been planted.); 53. 54. 55. public static void log(String msg) 56. System.out.println(msg); 57. 58. 59. /有无籽方法 60. public boolean getSeedless() 61. return seedless; 62. 63. 64. public void setSeedlees(boolean seedless) 65. this.seedless = seedless; 66. 67. 68. 69. /草莓类 70. public class St

17、rawberry implements Fruit 71. public void grow() 72. log(Strawberry is growing.); 73. 74. 75. public void harvest() 76. log(Strawberry has been harvested.); 77. 78. 79. public void plant() 80. log(Strawberry has been planted.); 81. 82. 83. public static void log(String msg) 84. System.out.println(ms

18、g); 85. 86. 87. 88. /农场园丁类，由他决定创建哪种水果类的实例 89. public class FruitGardener 90. /静态工厂方法 91. public static Fruit factory(String which) throws BadFruitException 92. if(which.equalslgnoreCase(apple) 93. return new Apple(); 94. else if(which.equalslgnoreCase(grape) 95. return new Grape(); 96. else if(which

19、.equalslgnoreCase(strawberry) 97. return new Strawberry(); 98. else 99. throw new BadFruitException(Bad fruit request); 100. 101. 102. 103. 104. /异常类 105. public class BadFruitException extends Exception 106. public BadFruitException(String msg) 107. super(msg); 108. 109. 110. 111. /测试类 112. public

20、class Test 113. FruitGardener gardener =new FruitGardener(); 114. try 115. gardener.factory(grape); 116. gardener.factory(apple); 117. gardener.factory(strawberry); 118. gardener.factory(banana); /抛出异常 119. catch(BadFruitException e) 120. System.out.println(dontt has this fruit.); 121. 122. 123. 2、举

21、例：/水果接口public interface Fruitvoid grow();/生长void harvest();/收获void plant();/种植/苹果类public class Apple implements Fruitprivate int treeAge/树龄public void grow()log(Apple is growing.);public void harvest()log(Apple has been harvented.);public void plant()log(Apple has been planted.);/辅助方法public static v

22、oid log(String msg)System.out.println(msg);public int getTreeAge()return treeAge;public void setTreeAge(int treeAge)this.treeAge = treeAge;/葡萄类public class Grape implements Fruitprivate boolean seedless;public void grow()log(Grape is growing.);public void harvest()log(Grape has been harvested.);publ

23、ic void plant()log(Grape has been planted.);public static void log(String msg)System.out.println(msg);/有无籽方法public boolean getSeedless()return seedless;public void setSeedlees(boolean seedless)this.seedless = seedless;/草莓类public class Strawberry implements Fruitpublic void grow()log(Strawberry is gr

24、owing.);public void harvest()log(Strawberry has been harvested.);public void plant()log(Strawberry has been planted.);public static void log(String msg)System.out.println(msg);/农场园丁类，由他决定创建哪种水果类的实例public class FruitGardener/静态工厂方法public static Fruit factory(String which) throws BadFruitExceptionif(w

25、hich.equalslgnoreCase(apple)return new Apple();else if(which.equalslgnoreCase(grape)return new Grape();else if(which.equalslgnoreCase(strawberry)return new Strawberry();elsethrow new BadFruitException(Bad fruit request);/异常类public class BadFruitException extends Exceptionpublic BadFruitException(Str

26、ing msg)super(msg);/测试类public class TestFruitGardener gardener =new FruitGardener();trygardener.factory(grape);gardener.factory(apple);gardener.factory(strawberry);gardener.factory(banana);/抛出异常catch(BadFruitException e)System.out.println(dontt has this fruit.);3、三个角色： 1、工厂类（Creator）角色：在客户端的直接调用下创建产

27、品对象 2、抽象产品角色：能够用一个接口或者一个抽象类实现 3、具体产品角色：工厂方法模式所创建的任何对象差不多上那个角色的实例 4、假如工厂方法总是循环使用同一个产品对象，那么那个工厂对象能够使用一个属性来存储那个产品对象。 每一次客户端调用工厂方法时，工厂方法总是提供这同一个对象。 假如工厂方法永久循环使用固定数目的一些产品对象，而且这些产品对象的数目并不大的话， 能够使用一些私有属性存储对这些产品对象的引用。比如：一个永久只提供一个产品对象的工厂对象 能够使用一个静态变量存储对那个产品对象的引用。 假如工厂方法使用数目不确定，或者数目较大的一些产品对象的话，使用属性变量存储对这些产品对象

28、的引用就不方便了， 这时候 就应当使用聚拢对象存储对产品对象的引用。 5、其他模式; 1、单例模式：单例模式要求单例类的构造子是私有的，从而客户端不能直接将之实例化，而必须通过那个静态工厂方法将之实例化， 而且单例类自身是自己的工厂角色。单例类自己负责创建自身的实例 单例类使用一个静态属性存储自己的唯一的实例，工厂方法永久仅提供这一个实例 2、多例模式：它是对单例模式的推广，多例模式也禁止外界直接将之实例化，同时通过静态工厂方法想外界提供循环使用的自身的实例， 多例模式能够有多个实例 多例模式具有一个聚拢属性，通过向那个聚拢属性登记差不多创建过的实例达到循环使用实例的目的， 它还拥有一个内部状

29、态，每一个内部状态都只有一个实例存在 依照外界传入的参量，工厂方法能够查询自己的登记聚拢，假如具有那个状态的实例差不多存在， 就直接将那个实例提供给外界：反之，就首先创建一个新的满足要求的实例，将之登记到聚拢中，然后再提供客户端。 3、备忘录模式：单例模式和多例模式使用一个属性或者聚拢属性来登记所创建的产品对象，一边能够通过查询那个属性或者聚拢属性 找到并共享差不多创建了的产品对象，这确实是备忘录模式的应用。 4、MVC模式：是更高层次上的架构模式。 包括：合成模式、策略模式、观看者模式、也有可能会包括装饰模式、调停者模式、迭代子模式以及工厂方法模式等。 ：假如系统需要有多个操纵器参与那个过程

30、的话，简单工厂模式就不适合了，应当考虑使用工厂方法模式。 6、简单工厂模式的优点己缺点 优点：模式的核心是工厂类，那个类有必要的推断逻辑，能够决定在什么时候创建哪一个产品类的实例。 而客户端则能够免除直接创建产品对象的责任，而仅仅负责“消费”产品。简单工厂模式通过这种做法实现了对责任的分割 缺点：1)那个工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类，有人把这种类叫做上帝类（God Class）。 假如那个全能类代表的是农场的一个具体园丁的话，那么那个园丁就需要对所有的产品负责，成了农场的关键人物， 他什么时候不能正常工作了，整个农场都要受到阻碍； 2)将这么多的逻辑集中放在一个类里

31、面的另外一个缺点是，当产品类有不同的接口种类时，工厂需要推断在什么时候创建某种产品， 这种对时机的推断和对哪一种具体产品的推断逻辑混合在一起，使得系统在今后进行功能扩展时较为困难。 这一缺点在工厂方法模式中得到克服 3）由于简单工厂模式使用静态方法作为工厂反尬，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。 这一缺点会在工厂方法模式中得到克服 7、“开闭”原则要求一个系统的设计能够同意系统在无需修改的情况下，扩展其功能。 要求系统同意当新的产品加入系统中时，而无需对现有代码进行修改，这一点关于产品消费者角色是成立的，而关于工厂角色是不成立的 一般而言：一个系统总是能够划分成

32、为产品的消费者角色（Client）、产品的工厂角色（Factory）以及产品角色（Product）三个子系统 关于产品消费者角色来讲，任何时候需要某种产品，只需向工厂角色请求即可，而工厂角色在接到请求后， 会自行推断创建和提供哪一个产品，因此，产品消费者角色无需明白它得到的是哪一个产品， 产品消费者角色无需修改就能够接纳新的产品，而接纳新的产品意味着要修改那个工厂角色的源代码 （简单工厂角色只在有限的程度上支持“开闭”原则）工厂方法（Factory Method）模式：1、工厂方法模式是类的创建模式，又叫做虚拟构造子模式或者多态性工厂模式 工厂方法模式的用意是定义一个创建产品对象的工厂接口，将

33、实际创建工作推迟到子类中。 一般而言工厂方法模式的系统设计到以下几种角色： 1） 抽象工厂（Creator）角色：担任那个角色的是工厂方法模式的核心，它是与应用程序无关的， 任何在模式之中个窗对象的工厂类必须实现那个接口，在实际系统中，那个角色也使用抽象类实现 2） 具体工厂（Concrete Creator）角色：担任那个角色的是实现了抽象工厂接口的具体java类。 具体工厂角色含有与用应紧密相关的逻辑，同时受到应用程序的调用以创建产品对象。 3） 抽象产品角色：工厂方法模式所创建的对象的超类型，也确实是产品对象的共同父类或共同拥有的接口， 在实际应用中，那个角色也常常使用抽象java类实现

34、 4） 具体产品角色：那个角色实现了抽象产品角色所声明的接口。工厂方法模式所创建的每一个对象差不多上某个具体产品角色的实例 Java代码 1.2、举例： 2. /抽象工厂（角色）接口 3. public interface Creator 4. /工厂方法 5. public Product factory(); 6. 7. 8. /抽象产品（角色）接口 9. public interface Product 10. 11. /一个没有声明任何方法的接口叫做标识接口 12. 13. /具体工厂（角色）类 14. public class ConcreteCreator1 implements

35、Creator 15. /工厂方法 16. public Product factory() 17. return new ConcreteProduct1(); 18. 19. 20. 21. public class ConcreteCreator2 implements Creator 22. /工厂方法 23. public Product factory() 24. return new ConcreteProduct2(); 25. 26. 27. 28. /具体产品（角色）类 29. public class ConcreteProduct1 implements Product

36、 30. public ConcreteProduct1() 31. /do somthing 32. 33. 34. 35. public class ConcreteProduct2 implements Product 36. public ConcreteProduct2() 37. /do somthing 38. 39. 40. 41. /客户端（角色）类 42. public class Client 43. private static Creator creator1,creator2; 44. private static Product prod1,prod2; 45.

37、46. public static void main(String args) 47. creator1 = new ConcreteCreator1(); 48. prod1 = creator1.factory(); 49. creator2 = new ConcreteCreator2(); 50. prod2 = creator2.factory(); 51. 52. 2、举例：/抽象工厂（角色）接口public interface Creator/工厂方法public Product factory();/抽象产品（角色）接口public interface Product/一个没

38、有声明任何方法的接口叫做标识接口/具体工厂（角色）类public class ConcreteCreator1 implements Creator/工厂方法public Product factory()return new ConcreteProduct1();public class ConcreteCreator2 implements Creator/工厂方法public Product factory()return new ConcreteProduct2();/具体产品（角色）类public class ConcreteProduct1 implements Productpu

39、blic ConcreteProduct1()/do somthingpublic class ConcreteProduct2 implements Productpublic ConcreteProduct2()/do somthing/客户端（角色）类public class Clientprivate static Creator creator1,creator2;private static Product prod1,prod2;public static void main(String args)creator1 = new ConcreteCreator1();prod1

40、= creator1.factory();creator2 = new ConcreteCreator2();prod2 = creator2.factory();Client对象的活动能够分为两部分 1） 客户端创建 ConcreteCreator1 对象，这时客户端所持有变量的静态类型是Creator，而实际类型是 ConcreteCreator1，然后，客户端调用 ConcreteCreator1 对象的工厂方法 factory() ，接着后者调用 ConcreteProduct1 的构造子创建出产品对象 Java代码 1.2、举例： 2. /抽象工厂角色（水果园丁） 3. public

41、 interface FruitGardener 4. /工厂方法 5. public Fruit factory(); 6. 7. 8. /具体工厂类（苹果园丁） 9. public class AppleGardener implements FruitGardener 10. public Fruit factory() 11. return new Apple(); 12. 13. 14. 15. /（草莓园丁） 16. public class StrawberryGardener implements FuritGardener 17. public Fruit factory()

42、 18. return new Strawberry(); 19. 20. 21. 22. /（葡萄园丁） 23. public class GrapeGardener implements FuritGardener 24. public Fruit factory() 25. return new Grape(); 26. 27. 28. 29. /抽象产品角色（水果接口） 30. public interface Fruit 31. void grow(); 32. void harvest(); 33. void plant(); 34. 35. 36. /具体产品角色（苹果类） 37

43、. public class Apple implements Fruit 38. private int treeAge; 39. 40. public void grow() 41. log(Apple is growing.); 42. 43. 44. public void harvest() 45. log(Apple has been harvested.); 46. 47. 48. public void plant() 49. log(Apple has been planted.); 50. 51. 52. public static void log(String msg)

44、 53. System.out.println(msg); 54. 55. 56. public int getTreeAge() 57. return treeAge; 58. 59. 60. public void setTreeAge(int treeAge) 61. this.treeAge = treeAge; 62. 63. 64. /其他同上 2、举例：/抽象工厂角色（水果园丁）public interface FruitGardener/工厂方法public Fruit factory();/具体工厂类（苹果园丁）public class AppleGardener imple

45、ments FruitGardenerpublic Fruit factory()return new Apple();/（草莓园丁）public class StrawberryGardener implements FuritGardenerpublic Fruit factory()return new Strawberry();/（葡萄园丁）public class GrapeGardener implements FuritGardenerpublic Fruit factory()return new Grape();/抽象产品角色（水果接口）public interface Fr

46、uitvoid grow();void harvest();void plant();/具体产品角色（苹果类）public class Apple implements Fruitprivate int treeAge;public void grow()log(Apple is growing.);public void harvest()log(Apple has been harvested.);public void plant()log(Apple has been planted.);public static void log(String msg)System.out.prin

47、tln(msg);public int getTreeAge()return treeAge;public void setTreeAge(int treeAge)this.treeAge = treeAge;/其他同上3、工厂方法返还的类型 工厂返还的应当是抽象类型，而不是具体类型，只有如此才能保证整队产品的多态性，调用该工厂方法的客户端能够针对抽象编程，依靠于一个抽象产品类型，而不是具体产品类型。 在专门情况下，工厂方法仅仅返还一个具体产品类型，那个时候工厂方法模式的功能就退化了，表现为针对产品角色的多态性的丧失，客户端从工厂方法的静态类型能够明白将要得到的是什么类型的对象，而这违背了工厂

48、方法模式的用意 4、与其他模式的关系 1、模板方法模式 工厂方法模式常常与模板方法模式一起联合使用，其缘故有二： 一、两个模式差不多上基于方法的，工厂方法模式是基于多态性的工厂方法的，而模板方法模式是基于模板方法和基于方法的 二、两个模式的哦将具体工作交给子类，工厂方法模式将创建工作推延给子类，模板方法模式将生于逻辑交给子类 2、MVC模式 工厂方法模式总是设计到两个等级结构中的对象，而这两个等级结构能够分不是MVC模式中的操纵器和视图。一个MVC模式能够有多个操纵器和多个视图，操纵器端能够创建合适的视图断，如同工厂角色创建合适的对象角色一样，模型端则能够充当那个创建过程的客户端 3、亨元模式

49、 使用了带有逻辑的工厂方法 4、备忘录模式 亨元模式使用了一个聚拢来等级所创建的产品对象，以便能够通过查询那个聚拢找到和共享差不多创建了的产品对象，这确实是备忘录模式的应用 Java代码 1.5、举例： 2. 问题：某一个商业软件产品需要支持Sybase和Oracle数据库。那个系统需要如此一个查询运行期系统，依照客户需要，能够随时向Sybase和Oracle数据库引擎发出查询 3. 答案：能够看出，那个系统是由一个客户端Client，一个抽象工厂角色QueryRunner，两个具体工厂角色SybaseQueryRunner和OracleQueryRunner，以及产品角色组成的 4. 关于客

50、户端Client而言，系统的抽象产品角色是ResultSet接口，而具体产品角色确实是java.sql.Connection所返还的具体ResultSet对象，createSql()方法和createConnection()方法实际上也是工厂方法，他们的产品是SQL语句和Connection对象 5. /java抽象类QueryRunner 6. import java.sql.Connection; 7. import java.sql.ResultSet; 8. 9. public abstract class QueryRunner 10. public ResultSet run()

51、throws Exception 11. Connection conn = createConnection(); 12. String sql = createSql(); 13. return runSql(conn,sql); 14. 15. protected abstract Connection createConnection(); 16. protected abstract String createSql(); 17. protected abstract ResultSet runSql(Connection conn.String sql)throws Excepti

52、on; 18. 19. 20. /具体工厂类 21. import java.sql.Connection; 22. import java.sql.Statement; 23. import java.sql.ResultSet; 24. 25. public class SybaseQueryRunner extends QueryRunner 26. public Connection createConnection() 27. return null; 28. 29. 30. protected String createSql() 31. return select * from

53、customers; 32. 33. 34. protected ResultSet runSql(Connection conn,String sql) throws Exception 35. Statement stmt = conn.createStatement(); 36. return stmt.executeQuery(sql); 37. 38. 39. 40. /具体工厂类 41. import java.sql.Connection; 42. import java.sql.Statement; 43. import java.sql.ResultSet; 44. 45.

54、public class OracleQueryRunner extends QueryRunner 46. public Connection createConnection() 47. return null; 48. 49. 50. protected String createSql() 51. return select * from customers; 52. 53. 54. protected ResultSet runSql(Connection conn, String sql) throws Exception 55. Statement stmt = conn.cre

55、ateStatement(); 56. return stmt.executeQuery(sql); 57. 58. 59. 60. /客户端 61. import java.sql.ResultSet; 62. 63. public class Client 64. private static QueryRunner runner; 65. 66. public static void main(String args) throws Exception 67. runner = new SybaseQueryRunner(); 68. ResultSet rs = runner.run(); 69. 70. 71. 以上给出的答案中，使用了模板方法模式，在QueryRunner中，run()方法确实是一个模板方法，那个方法代表一个顶极逻辑：返还产寻的结果ResultSet Java与模式之工厂模式学习Facotry Pattern包括了三种形态Simple Factory Factory Method Abstract Factory 下面分不进行学习Simple Fac