51CTO下载-java常用的设计模式

1、工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。

5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。

6、适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。

9、装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

10、门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。

11、享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规

类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。

12、代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

13、责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接 起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。

14、命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。

15、解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。

16、迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

17、调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

18、备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。

19、观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

20、状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。

21、策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

22、模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

23、访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。

工厂模式的几种形态：

1、简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式。 2、工厂方法模式，又称为多态性工厂(Polymorphic Factory)模式 3、抽象工厂模式，又称工具（Kit或ToolKit）模式

简单工厂模式（Simple Factory）

1、模式：

简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory 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(\ 15. } 16.

17. public void harvest(){

18. log(\ 19. } 20.

21. public void plant(){

22. log(\ 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 setTreeAge(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(\ 45. } 46.

47. public void harvest(){

48. log(\ 49. } 50.

51. public void plant(){

52. log(\ 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 Strawberry implements Fruit{ 71. public void grow(){

72. log(\ 73. } 74.

75. public void harvest(){

76. log(\ 77. } 78.

79. public void plant(){

80. log(\ 81. } 82.

83. public static void log(String msg){ 84. System.out.println(msg); 85. } 86. } 87.

88. //农场园丁类，由他决定创建哪种水果类的实例 89. public class FruitGardener{ 90. //静态工厂方法

91. public static Fruit factory(String which) throws BadFruitException{ 92. if(which.equalslgnoreCase(\ 93. return new Apple();

94. }else if(which.equalslgnoreCase(\ 95. return new Grape();

96. }else if(which.equalslgnoreCase(\ 97. return new Strawberry(); 98. }else{

99. throw new BadFruitException(\ 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 class Test{

113. FruitGardener gardener =new FruitGardener(); 114. try{

115. gardener.factory(\ 116. gardener.factory(\

117. gardener.factory(\

118. gardener.factory(\抛出异常 119. }catch(BadFruitException e){

120. System.out.println(\ 121. } 122. } 123. 2、举例： //水果接口 public interface Fruit{ void grow(); //生长 void harvest(); //收获 void plant(); //种植 } //苹果类 public class Apple implements Fruit{ private int treeAge //树龄 public void grow(){ log(\ } public void harvest(){ log(\ } public void plant(){ log(\ } //辅助方法 public static void log(String msg){ System.out.println(msg); } public int getTreeAge(){ return treeAge; } public void setTreeAge(int treeAge){ this.treeAge = treeAge; } } //葡萄类 public class Grape implements Fruit{

private boolean seedless; public void grow(){ log(\ } public void harvest(){ log(\ } public void plant(){ log(\ } 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 Fruit{ public void grow(){ log(\ } public void harvest(){ log(\ } public void plant(){ log(\ } public static void log(String msg){ System.out.println(msg);

} } //农场园丁类，由他决定创建哪种水果类的实例 public class FruitGardener{ //静态工厂方法 public static Fruit factory(String which) throws BadFruitException{ if(which.equalslgnoreCase(\ return new Apple(); }else if(which.equalslgnoreCase(\ return new Grape(); }else if(which.equalslgnoreCase(\ return new Strawberry(); }else{ throw new BadFruitException(\ } } } //异常类 public class BadFruitException extends Exception{ public BadFruitException(String msg){ super(msg); } } //测试类 public class Test{ FruitGardener gardener =new FruitGardener(); try{ gardener.factory(\ gardener.factory(\ gardener.factory(\ gardener.factory(\//抛出异常 }catch(BadFruitException e){ System.out.println(\ } }

3、三个角色：

1、工厂类（Creator）角色：在客户端的直接调用下创建产品对象 2、抽象产品角色：可以用一个接口或者一个抽象类实现

3、具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例

4、如果工厂方法总是循环使用同一个产品对象，那么这个工厂对象可以使用一个属性来存储这个产品对象。

每一次客户端调用工厂方法时，工厂方法总是提供这同一个对象。

如果工厂方法永远循环使用固定数目的一些产品对象，而且这些产品对象的数目并不大的话，

可以使用一些私有属性存储对这些产品对象的引用。比如：一个永远只提供一个产品对象的工厂对象

可以使用一个静态变量存储对这个产品对象的引用。

如果工厂方法使用数目不确定，或者数目较大的一些产品对象的话，使用属性变量存储对这些产品对象的引用就不方便了，

这时候 就应当使用聚集对象存储对产品对象的引用。

5、其他模式;

1、单例模式：单例模式要求单例类的构造子是私有的，从而客户端不能直接将之实例化，而必须通过这个静态工厂方法将之实例化，

而且单例类自身是自己的工厂角色。单例类自己负责创建自身的实例

单例类使用一个静态属性存储自己的唯一的实例，工厂方法永远仅提供这一个实例

2、多例模式：它是对单例模式的推广，多例模式也禁止外界直接将之实例化，同时通过静态工厂方法想外界提供循环使用的自身的实例， 多例模式可以有多个实例

多例模式具有一个聚集属性，通过向这个聚集属性登记已经创建过的实例达到循环使用实例的目的，

它还拥有一个内部状态，每一个内部状态都只有一个实例存在

根据外界传入的参量，工厂方法可以查询自己的登记聚集，如果具有这个状态的实例已经存在，

就直接将这个实例提供给外界：反之，就首先创建一个新的满足要求的实例，将之登记到聚集中，然后再提供客户端。

3、备忘录模式：单例模式和多例模式使用一个属性或者聚集属性来登记所创建的产品对象，一边可以通过查询这个属性或者聚集属性

找到并共享已经创建了的产品对象，这就是备忘录模式的应用。

4、MVC模式：是更高层次上的架构模式。

包括：合成模式、策略模式、观察者模式、也有可能会包括装饰模式、调停者模式、迭代子模式以及工厂方法模式等。

＊＊＊＊：如果系统需要有多个控制器参与这个过程的话，简单工厂模式就不适合了，应当考虑使用工厂方法模式。

6、简单工厂模式的优点己缺点

优点：模式的核心是工厂类，这个类有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例。

而客户端则可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。简单工厂模式通过这种做法实现了对责任的分割

缺点：1)这个工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类，有人把这种类叫做上帝类（God Class）。

如果这个全能类代表的是农场的一个具体园丁的话，那么这个园丁就需要对所有的产品负责，成了农场的关键人物，

他什么时候不能正常工作了，整个农场都要受到影响；

2)将这么多的逻辑集中放在一个类里面的另外一个缺点是，当产品类有不同的接口种类时，工厂需要判断在什么时候创建某种产品，

这种对时机的判断和对哪一种具体产品的判断逻辑混合在一起，使得系统在将来进行功能扩展时较为困难。

这一缺点在工厂方法模式中得到克服

3）由于简单工厂模式使用静态方法作为工厂反尬，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。

这一缺点会在工厂方法模式中得到克服 7、“开——闭”原则要求一个系统的设计能够允许系统在无需修改的情况下，扩展其功能。 要求系统允许当新的产品加入系统中时，而无需对现有代码进行修改，这一点对于产品消费者角色是成立的，而对于工厂角色是不成立的

一般而言：一个系统总是可以划分成为产品的消费者角色（Client）、产品的工厂角色（Factory）以及产品角色（Product）三个子系统 对于产品消费者角色来说，任何时候需要某种产品，只需向工厂角色请求即可，而工厂角色在接到请求后，

会自行判断创建和提供哪一个产品，所以，产品消费者角色无需知道它得到的是哪一个产品，

产品消费者角色无需修改就可以接纳新的产品，而接纳新的产品意味着要修改这个工厂角色的源代码

（简单工厂角色只在有限的程度上支持“开—闭”原则）

工厂方法（Factory Method）模式：

1、工厂方法模式是类的创建模式，又叫做虚拟构造子模式或者多态性工厂模式

工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。

一般而言工厂方法模式的系统设计到以下几种角色：

1） 抽象工厂（Creator）角色：担任这个角色的是工厂方法模式的核心，它是与应用程序无关的，

任何在模式之中个窗对象的工厂类必须实现这个接口，在实际系统中，这个角色也使用抽象类实现

2） 具体工厂（Concrete Creator）角色：担任这个角色的是实现了抽象工厂接口的具体java类。

具体工厂角色含有与用应密切相关的逻辑，并且受到应用程序的调用以创建产品对象。

3） 抽象产品角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口，

在实际应用中，这个角色也常常使用抽象java类实现

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 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{ 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.

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{ } //一个没有声明任何方法的接口叫做标识接口 //具体工厂（角色）类 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 Product{ public ConcreteProduct1(){ //do somthing } } public class ConcreteProduct2 implements Product{ public ConcreteProduct2(){ //do somthing } } //客户端（角色）类 public class Client{ private static Creator creator1,creator2; private static Product prod1,prod2; public static void main(String args[]){ creator1 = new ConcreteCreator1(); prod1 = creator1.factory(); creator2 = new ConcreteCreator2(); prod2 = creator2.factory(); } }

Client对象的活动可以分为两部分

1） 客户端创建 ConcreteCreator1 对象，这时客户端所持有变量的静态类型是Creator，而实际类型是 ConcreteCreator1，然后，客户端调用 ConcreteCreator1 对象的工厂方法 factory() ，接着后者调用 ConcreteProduct1 的构造子创建出产品对象

Java代码

1.2、举例：

2. //抽象工厂角色（水果园丁） 3. public 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(){

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. public class Apple implements Fruit{ 38. private int treeAge; 39.

40. public void grow(){

41. log(\ 42. } 43.

44. public void harvest(){

45. log(\ 46. } 47.

48. public void plant(){

49. log(\ 50. } 51.

52. public static void log(String msg){ 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 implements FruitGardener{ public Fruit factory(){ return new Apple(); } } //......（草莓园丁） public class StrawberryGardener implements FuritGardener{ public Fruit factory(){ return new Strawberry(); } } //......（葡萄园丁） public class GrapeGardener implements FuritGardener{ public Fruit factory(){ return new Grape(); } }

//抽象产品角色（水果接口） public interface Fruit{ void grow(); void harvest(); void plant(); } //具体产品角色（苹果类） public class Apple implements Fruit{ private int treeAge; public void grow(){ log(\ } public void harvest(){ log(\ } public void plant(){ log(\ } public static void log(String msg){ System.out.println(msg); } public int getTreeAge(){ return treeAge; } public void setTreeAge(int treeAge){ this.treeAge = treeAge; } } //其他同上..........................

3、工厂方法返还的类型

工厂返还的应当是抽象类型，而不是具体类型，只有这样才能保证整队产品的多态性，调用该工厂方法的客户端可以针对抽象编程，依赖于一个抽象产品类型，而不是具体产品类型。 在特殊情况下，工厂方法仅仅返还一个具体产品类型，这个时候工厂方法模式的功能就退化了，表现为针对产品角色的多态性的丧失，客户端从工厂方法的静态类型可以知道将要得到的是什么类型的对象，而这违背了工厂方法模式的用意

4、与其他模式的关系

1、模板方法模式

工厂方法模式常常与模板方法模式一起联合使用，其原因有二：

一、两个模式都是基于方法的，工厂方法模式是基于多态性的工厂方法的，而模板方法模式是基于模板方法和基于方法的

二、两个模式的哦将具体工作交给子类，工厂方法模式将创建工作推延给子类，模板方法模式将生于逻辑交给子类

2、MVC模式

工厂方法模式总是设计到两个等级结构中的对象，而这两个等级结构可以分别是MVC模式中的控制器和视图。一个MVC模式可以有多个控制器和多个视图，控制器端可以创建合适的视图断，如同工厂角色创建合适的对象角色一样，模型端则可以充当这个创建过程的客户端

3、亨元模式

使用了带有逻辑的工厂方法

4、备忘录模式

亨元模式使用了一个聚集来等级所创建的产品对象，以便可以通过查询这个聚集找到和共享已经创建了的产品对象，这就是备忘录模式的应用

Java代码

1.5、举例：

2. 问题：某一个商业软件产品需要支持Sybase和Oracle数据库。这个系统需要这样一个查询运行期系统，根据客户需要，可以随时向Sybase和Oracle数据库引擎发出查询 3. 答案：可以看出，这个系统是由一个客户端Client，一个抽象工厂角色QueryRunner，两个具体工厂角色SybaseQueryRunner和OracleQueryRunner，以及产品角色组成的

4. 对于客户端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() 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 Exception; 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 \ 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. public class OracleQueryRunner extends QueryRunner{ 46. public Connection createConnection(){ 47. return null; 48. } 49.

50. protected String createSql(){

51. return \ 52. } 53.

54. protected ResultSet runSql(Connection conn, String sql) throws Exception{ 55. Statement stmt = conn.createStatement(); 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包括了三种形态 1. Simple Factory 2. Factory Method 3. Abstract Factory 下面分别进行学习 Simple Factory

简单工厂模式往往是普通工厂模式的一个特例。简单工厂模式基本是用一个类来模拟工厂，通过该工厂类的静态方法返回具体的产品类，而这些产品又源自一个抽象的产品（当然，这儿可能会存在多种抽象产品，即有多种不同类型的产品，如蔬菜、瓜果等等），即静态工厂模式。书中提及了几个对象：水果以及具体的水果，园丁；园丁根据得到的参量来决定提取某种水果。如果存在多种抽象产品，必须考察抽象产品是由抽象类来实现还是用接口来表现了，如果具体产品之间拥有共同的商业逻辑，一般都应用抽象类来表现，否则应用接口来表现，在一个类型的等级结构中，将共同的部分尽量向上塑造。相应的，工厂也可以分为多个工厂，各自负责不同种类的产品即抽象类。

考虑一下，如果我们新增了一种产品，那么在我们的静态工厂类中就必须再加入返回该新增的产品类的方法，是需要修改这个工厂类的。这个到底应该如何才能不修改工厂类呢？或许我们的工厂类不应该同具体产品类来发生关联关系。

Factory Method

工厂方法模式是类的创建模式，定义一个创建工厂接口，将实际的创建工作推到子类工厂中。也就是原本的静态类变成了一个抽象类或接口，而将制造的任务交给底下的具体实现类来完成。工厂方法模式似乎同抽象工厂模式很类似，但或许引入产品族后可以做一下比较。

抽象产品A（具体产品A1, 具体产品A2），抽象工厂F可以只有一个具体工厂，实现生成A的抽象方法。即工厂方法模式是将注意集中在可抽象产品概念上（意即多个具体产品可抽象化）。

如果引入产品族的概念，即有多个抽象产品，那么就必须对应不同的抽象产品形成不同的抽象工厂层，这会打破工厂的独立性，乃至形成一个庞大的工厂族。自然工厂方法模式不能很好的解决这种问题。因为有了产品族的引入，自然就引入了抽象工厂模式。 Abstract Factory

这里真正引入了产品族、工厂族的概念。在实际的开发中，我们所面对的产品是分等级的，库存管理系统尤为显现。抽象工厂模式为客户端提供一个接口，使客户端在不必指定产品的具体类型就可以创建多个产品对象。

产品族也就是好有多个抽象产品，其下可能还拥有抽象产品和具体产品。抽象工厂模式，首先抽象出所有产品族的生产方法： java 代码

1. public interface Creator {

2. ProductA factoryA(); //返回产品ProductA 3. ProductB factoryB(); //返回产品ProductB 4. }

不难发现，这种抽象与抽象产品的种类有关，有多少种抽象产品，就应有多少种抽象工厂方法。具体的生产交给具体工厂去实现。 java 代码

1. /**

2. 这是抽象工厂的一个具体实现，它只负责生产ProductA1和ProductB1两种具体产品 3. */

4. public class ConcreteCreator1 implements Creator { 5. public ProductA factoryA() { 6. return new ProductA1(); 7. }

8.

9. public ProductB factoryB() { 10. return new ProductB1(); 11. } 12.}

可以清楚的发现，该具体工厂仅仅负责所有产品族的各1种产品。ProductA拥有ProductA1, ProductA2两种具体产品， ProductB拥有ProductB1, ProductB2两种具体产品，正因为有了产品族和\\这两种相对性，我们才能抽象出工厂接口来。可以很容易地写出ConcreteCreator2具体工厂来。

试想一下，如果我们给ProductB再增加2种甚至更多的产品的时候，是否我们需要增加2种或者更多的具体工厂类来实现抽象工厂呢？如果是，那么就会有多余的factoryA()方法被“空实现”。同样我们可以形成工厂族来避免这些问题。 假如我们已经实现了抽象工厂

Client想要某种或多种产品，我们通过抽象工厂提供给它一个接口； 工厂中增加已有抽象的具体产品，可以增加一个具体工厂而不需要去修改其它的设计；

工厂中要增加新的抽象层面的产品，新增一个抽象产品类，增加所需要的具体产品，那么抽象工厂层是否需要修改，这似乎就违背了不修改现有代码的初衷了。是，这很麻烦，因为你需要重新抽象，甚至要修改以前的代码。可以考虑用其它方法解决。 小结

简单工厂模式和工厂方法模式可以看作是抽象工厂模式特例，当我们把简单工厂模式中的实际工厂抽象出一个抽象工厂时，它就变成了一个工厂方法模式；当我们把工厂方法模式的产品等级变得更多一些，形成产品族的时候，它又能成为一个抽象工厂模式。

本文来源：https://www.bwwdw.com/article/50c.html