java设计模式之工厂模式详解编程语言

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码，使代码更容易被他们理解，保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式使软件工程的技师，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是他能被广泛应用的原因。

总体来说设计模式分类三大类：

创建性模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

工厂模式：

1. 工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。  
2. 工厂模式的几种形态：  
3. （1）简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method  
4. Pattern）。  
5. （2）工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模式  
6. 或虚拟构造子（Virtual Constructor）模式；  
7. （3）抽象工厂（Abstract Factory）模式，又称工具箱（Kit 或Toolkit）模式。  

简单工厂模式：

1. 简单工厂模式介绍  
2. 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据自变量的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。   
3.   
4.   
5. 简单工厂模式角色  
6. （1）工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体Java 类实现。  
7. （2）抽象产品（Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。抽象产品角色可以用一个Java 接口或者Java 抽象类实现。  
8. （3）具体产品（Concrete Product）角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体Java 类实现。  
9.   
10. 简单工厂模式的优缺点  
11. 简单工厂模式的优点如下：  
12. （1）工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。  
13. （2）客户端无需知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。  
14. （3）通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。  
15. 简单工厂模式的缺点如下：  
16. （1）由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。  
17. （2）使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。  
18. （3）系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。  
19. （3）简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。  
20.   
21. 简单工厂模式的适用环境  
22. （1）工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂；  
23. （2）客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。  

24. 1. 简单工厂模式的举例  
    2. 例：  
    3.  //抽象产品角色  
    4. public interface Car{  
    5.       public void drive();  
    6. }  
    7. //具体产品角色  
    8. public class Benz implements Car{  
    9.       public void drive() {  
    10.          System.out.println(“Driving Benz “);  
    11.       }  
    12. }  
    13. public class Bmw implements Car{  
    14.       public void drive() {  
    15.        System.out.println(“Driving Bmw “);  
    16.       }  
    17. }  
    18. //工厂类角色  
    19. public class Driver{  
    20.             //工厂方法.注意 返回类型为抽象产品角色  
    21.              public static Car driverCar(String s)throws Exception{  
    22.                    //判断逻辑，返回具体的产品角色给Client  
    23.                    if(s.equalsIgnoreCase(“Benz”))  
    24.                         return new Benz();  
    25.                    else if(s.equalsIgnoreCase(“Bmw”))  
    26.                             return new Bmw();  
    27.                      else throw new Exception();  
    28.            }  
    29. }  

工厂模式在Java标准库中的应用

根据不同的参数，getInstance()方法会返回不同的Calendar（日历）对象。

工厂方法模式：

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

在同一等级结构中，支持增加任意产品。

1. 工厂方法模式的介绍  
2.     工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。  
3. 在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。  
4.   
5. 工厂方法模式角色  
6. （1）抽象工厂（Creator）角色：担任这个角色的是工厂方法模式的核心，它是与应用程序无关的。任何在模式中创建对象的工厂类必须实现这个接口。在上面的系统中这个角色由Java 接口Creator 扮演；在实际的系统中，这个角色也常常使用抽象Java 类实现。  
7. （2）具体工厂（Concrete Creator）角色：担任这个角色的是实现了抽象工厂接口的具体Java 类。具体工厂角色含有与应用密切相关的逻辑，并且受到应用程序的调用以创建产品对象。在本系统中给出了两个这样的角色，也就是具体Java 类ConcreteCreator1 和ConcreteCreator2。  
8. （3）抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在本系统中，这个角色由Java 接口Product 扮演；在实际的系统中，这个角色也常常使用抽象Java 类实现。  
9. （4）具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所声明的接口。工厂方法模式所创建的每一个对象都是某个具体产品角色的实例。  
10.   
11. 工厂方法模式的优缺点  
12. 工厂方法模式的优点如下：  
13. （1）在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无需知道具体产品类的类名。  
14. （2）基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，正是因为所有的具体工厂类都具有同一抽象父类。  
15. （3）使用工厂方法模式的另一个优点是在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。  
16. 工厂方法模式的缺点如下：  
17. （1）在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。  
18. （2）由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。  
19.   
20. 工厂方法模式的适用环境  
21. 在以下情况下可以使用工厂方法模式：  
22. （1）一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。  
23. （2）一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。  
24. （3）将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无需关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。  
25.     
26. 工厂方法模式的举例  
27. 例：  
28. //抽象产品   
29. PenCore.java  
30. public abstract class PenCore{  
31. String color;  
32. public abstract void writeWord(String s);  
33. }  
34. //具体产品  
35. RedPenCore.java  
36. public class RedPenCore extends PenCore {  
37.     RedPenCore() {  
38.         color = “红色”;  
39.     }  
40.     public void writeWord(String s) {  
41.         System.out.println(“写出” + color + “的字” + s);  
42.     }  
43. }  
44. BluePenCore.java  
45. public class BluePenCore extends PenCore {  
46.     BluePenCore() {  
47.         color = “蓝色”;  
48.     }  
49.     public void writeWord(String s) {  
50.         System.out.println(“写出” + color + “的字” + s);  
51.     }  
52. }  
53. BlackPenCore.java  
54. public class BlackPenCore extends PenCore {  
55.     BlackPenCore() {  
56.         color = “黑色”;  
57.     }  
58.     public void writeWord(String s) {  
59.         System.out.println(“写出” + color + “的字” + s);  
60.     }  
61. }  
62. //抽象工厂类角色  
63. BallPen.java  
64. public abstract class BallPen {  
65.     BallPen(){  
66.         System.out.println(“生产一只装有”+getPenCore().color+“笔芯的圆珠笔”);  
67.     }  
68.     public abstract PenCore getPenCore();  
69. }  
70. //具体工厂类角色   
71. RedBallPen.java  
72. public class RedBallPen extends BallPen {  
73.     public PenCore getPenCore() {  
74.         return new RedPenCore();  
75.     }  
76. }  
77. BlueBallPen.java  
78. public class BlueBallPen extends BallPen {  
79.     public PenCore getPenCore() {  
80.         return new BluePenCore();  
81.     }  
82. }  
83. BlackBallPen.java  
84. public class BlackBallPen extends BallPen {  
85.     public PenCore getPenCore() {  
86.         return new BlackPenCore();  
87.     }  
88. }  

抽象工厂模式

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。

应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。

1. 抽象工厂模式的介绍  
2.     抽象工厂模式提供一个创建一系列或相互依赖的对象的接口，而无需指定它们具体的类。  
3.   
4. 抽象工厂模式角色  
5. 抽象工厂模式涉及到的系统角色  
6. （1）抽象工厂（AbstractFactory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用Java 接口或者抽象Java 类实现，而所有的具体工厂类必须实现这个Java 接口或继承这个抽象Java 类。  
7. （2）具体工厂类（Conrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体Java 类实现这个角色。  
8. （3）抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用Java 接口或者抽象Java 类实现这一角色。  
9. （4）具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。通常使用具体Java 类实现这个角色。  
10.    
11. 抽象工厂模式的优缺点  
12. 优点：  
13. （1） 隔离了具体类的生成，使得用户不需要知道什么被创建了。  
14. （2） 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。  
15. 缺点：  
16. （1）添加新的产品对像时，难以扩展抽象工厂以便生产新种类的产品。  
17.   
18. 抽象工厂模式的适用环境  
19. （1）一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节。这对于所有形态的工厂模式都是重要的；  
20. （2）一个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品；  
21. （3）同属于同一个产品族的产品是在一起使用的，这一约束必须要在系统的设计中体现出来；  
22. （4）系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。  
23.   
24. 抽象工厂模式的举例  
25. 例：  
26. //抽象产品  
27. UpperClothes.java  
28. public abstract class UpperClothes {  
29.     public abstract int getChestSize();  
30.     public abstract int getHeight();  
31.     public abstract String getName();  
32. }  
33. Trousers.java  
34. public abstract class Trousers {  
35.     public abstract int getWaistSize();  
36.     public abstract int getHeight();  
37.     public abstract String getName();  
38. }  
39. //具体产品  
40. WesternUpperClothes.java  
41. public class WesternUpperClothes extends UpperClothes {  
42.     private int chestSize;  
43.     private int height;  
44.     private String name;  
45.     WesternUpperClothes(String name,int chestSize,int height){  
46.         this.name=name;  
47.         this.chestSize=chestSize;  
48.         this.height=height;  
49.     }  
50.     public int getChestSize() {  
51.         return chestSize;  
52.     }  
53.     public int getHeight() {  
54.         return height;  
55.     }  
56.     public String getName() {  
57.         return name;  
58.     }  
59. }  
60. CowboyUpperClothes.java  
61. public class CowboyUpperClothes extends UpperClothes {  
62.     private int chestSize;  
63.     private int height;  
64.     private String name;  
65.     CowboyUpperClothes(String name,int chestSize,int height){  
66.         this.name=name;  
67.         this.chestSize=chestSize;  
68.         this.height=height;  
69.     }  
70.     public int getChestSize() {  
71.         return chestSize;  
72.     }  
73.     public int getHeight() {  
74.         return height;  
75.     }  
76.     public String getName () {  
77.         return name;  
78.     }  
79. }  
80. WesternTrousers.java  
81. public class WesternTrousers extends Trousers {  
82.     private int waistSize;  
83.     private int height;  
84.     private String name;  
85.     WesternTrousers(String name,int waistSize,int height){  
86.         this.name=name;  
87.         this.waistSize=waistSize;  
88.         this.height=height;  
89.     }  
90.     public int getHeight() {  
91.         return height;  
92.     }  
93.     public String getName() {  
94.         return name;  
95.     }  
96.     public int getWaistSize() {  
97.         return waistSize;  
98.     }  
99. }  
100. CowboyTrousers.java  
101. public class CowboyTrousers extends Trousers {  
102.     private int waistSize;  
103.     private int height;  
104.     private String name;  
105.     CowboyTrousers(String name,int waistSize,int height){  
106.         this.name=name;  
107.         this.waistSize=waistSize;  
108.         this.height=height;  
109.     }  
110.     public int getHeight() {  
111.         return height;  
112.     }  
113.     public String getName() {  
114.         return name;  
115.     }  
116.     public int getWaistSize() {  
117.         return waistSize;  
118.     }  
119. }  
120. //抽象工厂  
121. ClothesFactory.java  
122. public abstract class ClothesFactory {  
123.     public abstract UpperClothes createUpperClothes(int chestSize,int height);  
124.     public abstract Trousers createTrousers(int waistSize,int height);  
125. }  
126. //具体工厂  
127. BeijingClothesFactory.java  
128. public class BeijingClothesFactory extends ClothesFactory {  
129.     public Trousers createTrousers(int waistSize, int height) {  
130.         return new WesternTrousers(“北京牌裤子”,waistSize,height);  
131.     }  
132.     public UpperClothes createUpperClothes(int chestSize, int height) {  
133.         return new WesternUpperClothes(“北京牌上衣”,chestSize,height);  
134.     }  
135. }  
136. ShanghaiClothesFactory.java  
137. public class ShanghaiClothesFactory extends ClothesFactory {  
138.     public Trousers createTrousers(int waistSize, int height) {  
139.         return new WesternTrousers(“上海牌裤子”,waistSize,height);  
140.     }  
141.     public UpperClothes createUpperClothes(int chestSize, int height) {  
142.         return new WesternUpperClothes(“上海牌上衣”,chestSize,height);  
143.     }  
144. }  

小结

★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。

★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。

★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。

 

区别

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）   
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）  

 

以上三种工厂 方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。  

 

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

工厂方法有点：允许系统在不修改具体工厂角色的情况下引进新产品。 

抽象工厂优点：向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象 

注：工厂方法中，每个具体工厂类都只对应于一种产品，当增加产品的时候，同样要增加具体的工厂类，不存在产品族（即同一大类产品）的概念，而抽象工厂中，每个具体工厂类都是对应于多个产品，这些产品属于一个产品族，即一个具体工厂类对应于一个大的产品族，所以当增加了一个产品族时，再加一个具体工厂类继承或者实现抽象工厂类或接口，这样就又多了一个产品族，但是如果增加的是一个产品，则无能无力。

第二种表述方式

简单工厂、工厂方法和抽象工厂都是创建型的设计模式。

三者的共同点是：

1、都有两种作用不同的类：产品类和工厂类。其中，工厂类在自己的方法中实例化产品类（即使用new命令生成产品类的对象），并将生成的产品类的对象提供给外部使用。

2、创建的过程，都是类似的：工厂类得到一个标志（可以由程序输入，也可以读取配置文件中的内容），返回一个产品对象。 

三者的不同点：

1、简单工厂

简单工厂方法中，包括一个“抽象产品类”（该类可以是接口Interface，也可以是实际的类Class），所有需要的产品类都是该“抽象产品类”的子类（如果是接口的话，那么就是说所有产品类都继承了该接口）。

简单工厂一般只包含一个具体的工厂类，由该工厂类生成所有的产品类的对象。生成产品类的方法，其内部一般是类似于switch的结构，根据输入的标志，选择创建不同类型的对象。由于不知道创建的对象到底是哪个类的，所以方法的返回值的类型是“抽象产品类”。

 

2、工厂方法

抽象工厂中，包括“抽象工厂类”和“抽象产品类”，同时包含不只一个工厂类。所有的工厂类都必须是“抽象工厂类”的子类，所有的产品都必须是“抽象产品类”的子类。

和简单工厂比起来，工厂方法一般是从抽象工厂开始的。一般都是在抽象工厂类中提供一个静态方法，由该方法根据输入的标志，生成不同的具体工厂类，然后由具体的产品类生成具体的产品。注意，一个具体工厂类只能生成一种具体的产品类的对象，不同的具体工厂生成不同的产品，而不是像简单工厂中那样，一个工厂类可以生成多种不同产品类的对象。可以这么理解，在选择不同的具体工厂类的时候，就选择了生成的产品，相对于简单工厂，相当于将选择产品的动作提前了。

因为不知道创建的具体工厂类到底是哪一个，所以生成具体工厂类的静态方法的返回值的类型是“抽象工厂类”。具体工厂类生成产品类的方法，返回值的类型也要求是“抽象产品类”（因为前端调用的时候，需要使用同样的代码来访问）。 

3、抽象工厂

抽象工厂和工厂方法很类似，区别如下： 

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。 

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。       
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个