Java设计模式——工厂设计模式

向右看齐 2022-06-10 04:24 324阅读 0赞

# [Java设计模式——工厂设计模式 ][Java_] #

标签： [ java][java][工厂模式][Link 1]

2017-08-09 15:47  206人阅读 [评论][Link 2](0) 收藏 [举报][Link 3]

![category_icon.jpg][] 分类：

Java*（129）* ![arrow_triangle_20_down.jpg][] ![arrow_triangle_up.jpg][]

[作者同类文章][Link 4] *X*

工厂模式：主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。

工厂模式的形态  
工厂模式主要用一下几种形态：  
1：简单工厂（Simple Factory）。  
2：工厂方法（Factory Method）。  
3：抽象工厂（Abstract Factory）。  
  
简单工厂（Simple Factory）  
又叫 静态工厂 ，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。我们来看一个具体的例子：  
假设一家工厂，几生产洗衣机，有生产冰箱，还有空调等等..  
我们先为所有产品定义一个共同的产品接口

1.  **public** **interface** Product\{\}

![save_snippets_01.png][]

接着我们让这个工厂的所有产品都必须实现此接口

1.  **public** **class** Washer **implements** Product\{ 
2.     **public** Washer()\{ 
3.         System.out.println("洗衣机被制造了"); 
4.     \} 
5.  \} 
6.   
7.  **public** **class** Icebox **implements** Product\{ 
8.     **public** Icebox()\{ 
9.         System.out.println("冰箱被制造了"); 
10.    \} 
11. \} 
12.  
13. **public** **class** AirCondition **implements** Product\{ 
14.    **public** Icebox()\{ 
15.        System.out.println("空调被制造了"); 
16.    \} 
17. \}

![save_snippets.png][]

接下来我们来写一个工厂类，有它来负责生产以上的产品

1.  **public** **class** SimpleFactory \{ 
2.       
3.      **public** **static** Product factory(String productName) **throws** Exception\{ 
4.          **if**(productName.equals("Washer"))\{ 
5.              **return** **new** Washer(); 
6.          \}**else** **if**(productName.equals("Icebox"))\{ 
7.              **return** **new** Icebox(); 
8.          \}**else** **if**(productName.equals("AirCondition"))\{ 
9.              **return** **new** AirCondition(); 
10.         \}**else**\{ 
11.             **throw** **new** Exception("没有该产品"); 
12.         \} 
13.     \} 
14. \}

![save_snippets.png][]

好了，有了这个工厂类，我们就可以开始下定单了， SimpleFactory 将根据不同的定单类决定生产什么产品。

1.  **public** **static** **void** main(String\[\] args) \{ 
2.      **try** \{ 
3.                SimpleFactory.factory("Washer"); 
4.                SimpleFactory.factory("Icebox"); 
5.                SimpleFactory.factory("AirCondition"); 
6.              \} **catch** (Exception e) \{ 
7.          e.printStackTrace(); 
8.      \} 
9.  \}

![save_snippets.png][]

由上面的代码可以看出，简单工厂的核心就是一个 SimpleFactory 类，他拥有必要的逻辑判断能力和所有产品的创建权利，我们只需要向把定单给他，就能得到我们想要的产品。这使用起来似乎非常方便。  
但，实际上，这个 SimpleFactory 有很多的局限。首先，我们每次想要增加一种新产品的时候，都必须修改 SimpleFactory 的原代码。其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增，这对以后的维护简直就是恐怖两个字...  
还有就是，整个系统都严重依赖 SimpleFactory 类，只要 SimpleFactory 类一出问题，系统就进入不能工作的状态，这也是最为致命的一点....  
以上的不足将在工厂模式的另外两种状态中得到解决。  
  
工厂方法（Factory Method）  
上面的代码告诉我们， 简单工厂 并不简单，它是整个模式的核心，一旦他出了问题，整个模式都将受影响而不能工作，为了降低风险和为日后的维护、扩展做准备，我们需要对它进行重构，引入 工厂方法 。  
工厂方法为工厂类定义了接口，用多态来削弱了工厂类的职能，以下是工厂接口的定义：

1.  **public** **interface** Factory\{ 
2.    **public** Product create(); 
3.  \}

![save_snippets_01.png][]

我们再来定义一个产品接口

1.  **public** **interface** Product\{\}

![save_snippets_01.png][]

一下是实现了产品接口的产品类

![save_snippets.png][]

接下来，就是工厂方法的核心部分，也就是具体创建产品对象的具体工厂类，

1.  //创建洗衣机的工厂 
2.  **public** **class** CreateWasher **implements** Factory\{ 
3.      **public** Product create()\{ 
4.            **return** **new** Washer(); 
5.      \} 
6.  \} 
7.   
8.  //创建冰箱的工厂 
9.  **public** **class** CreateIcebox **implements** Factory\{ 
10.     **public** Product create()\{ 
11.           **return** **new** Icebox(); 
12.     \} 
13. \} 
14.  
15. //创建空调的工厂 
16. **public** **class** CreateAirCondition **implements** Factory\{ 
17.     **public** Product create()\{ 
18.           **return** **new** AirCondition(); 
19.     \} 
20. \}

![save_snippets.png][]

从上面创建产品对象的代码可以看出， 工厂方法 和 简单工厂 的主要区别是， 简单工厂 是把创建产品的职能都放在一个类里面，而 工厂方法 则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。但 工厂方法 也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如，工厂除了生产家电外产品，还生产手机产品，这样一来家电是手机就是两大产品家族了，这两大家族下面包含了数量众多的产品，每个产品又有多个型号，这样就形成了一个复杂的产品树了。如果用 工厂方法 来设计这个产品家族系统，就必须为每个型号的产品创建一个对应的工厂类，当有数百种甚至上千种产品的时候，也必须要有对应的上百成千个工厂类，这就出现了传说的类爆炸，对于以后的维护来说，简直就是一场灾难.....  
  
抽象工厂（Factory Method）  
抽象工厂 ：意的意图在于创建一系列互相关联或互相依赖的对象。<<Java设计模式>>  
我自己觉得 抽象工厂 是在 工厂方法 的基础上引进了分类管理的概念....  
工厂方法用来创建一个产品，它没有分类的概念，而抽象工厂则用于创建一系列产品，所以产品分类成了抽象工厂的重点，  
我们继续用上面的例子来说明：  
工厂生产的所有产品都用都用大写字母来标明它们的型号，比如冰箱，就有“冰箱-A",“冰箱-B",同样，其他的产品也都是遵守这个编号规则，于是就有了一下产品家族树  
  
冰箱：

1.    
      
2.  冰箱-A  
3.  冰箱-B

洗衣机：

1.    
      
2.  洗衣机-A  
3.  洗衣机-B

我们可以为冰箱和洗衣机分别定义两个产品接口，以对他们进行分类，

1.  //洗衣机接口 
2.  **public** **interface** Washer\{ 
3.  \} 
4.   
5.  //冰箱接口 
6.  **public** **interface** Icebox\{ 
7.  \}

![save_snippets.png][]

接着，我们分别创建这两个接口的具体产品

1.  //洗衣机-A 
2.  **public** **class** WasherA **implements** Washer\{ 
3.     **public** WasherA()\{ 
4.         System.out.println("洗衣机-A被制造了"); 
5.     \} 
6.  \} 
7.   
8.  //洗衣机-B 
9.  **public** **class** WasherB **implements** Washer\{ 
10.    **public** WasherB()\{ 
11.        System.out.println("洗衣机-B被制造了"); 
12.    \} 
13. \} 
14.  
15. //冰箱-A 
16. **public** **class** IceboxA **implements** Icebox\{ 
17.    **public** IceboxA()\{ 
18.        System.out.println("冰箱-A被制造了"); 
19.    \} 
20. \} 
21.  
22. //冰箱-B 
23. **public** **class** IceboxB **implements** Icebox\{ 
24.    **public** IceboxB()\{ 
25.        System.out.println("冰箱-B被制造了"); 
26.    \} 
27. \}

![save_snippets.png][]

到此，产品部分我们准备好了，接下来我们来处理工厂部分，我们先来定义工厂行为接口

1.  **public** **interface** Factory\{ 
2.         **public** Washer createWasher(); 
3.         **public** Icebox createIcebox(); 
4.  \}

![save_snippets_01.png][]

接下来我创造具体的工厂类，我们根据上面产品的接口，把型号A的产品分为一类，由一个工厂来管理，把型号为B的产品有另一个工厂管理，根据这个分类，我们可以实现如下的两个具体工厂类

1.  //创建型号为A的产品工厂 
2.  **public** **class** FactoryA **implements** Factory\{ 
3.         //创建洗衣机-A 
4.         **public** Washer createWasher()\{ 
5.              **return** **new** WasherA(); 
6.         \} 
7.   
8.         //创建冰箱-A 
9.         **public** Icebox createIcebox()\{ 
10.             **return** **new** IceboxA(); 
11.        \} 
12. \} 
13.  
14. //创建型号为B的产品工厂 
15. **public** **class** FactoryB **implements** Factory\{ 
16.        //创建洗衣机-B 
17.        **public** Washer createWasher()\{ 
18.             **return** **new** WasherB(); 
19.        \} 
20.  
21.        //创建冰箱-B 
22.        **public** Icebox createIcebox()\{ 
23.             **return** **new** IceboxB(); 
24.        \} 
25. \}

![save_snippets.png][]

这样，我们的抽象工厂就完成了。有上面可以看出，在运用上我觉得工厂方法和抽象工厂，都有自己的应用场景，并没有什么优劣之分，但在应用抽象工厂之前，要先对创建的对象进行系统的分类，这点很重要，好的产品分类规则能为具体工厂类的选择调用和以后的扩展提供清晰的思路.

[Java_]: http://blog.csdn.net/qq_37267015/article/details/76998423
[java]: http://www.csdn.net/tag/java
[Link 1]: http://www.csdn.net/tag/%e5%b7%a5%e5%8e%82%e6%a8%a1%e5%bc%8f
[Link 2]: http://blog.csdn.net/qq_37267015/article/details/76998423#comments
[Link 3]: http://blog.csdn.net/qq_37267015/article/details/76998423#report
[category_icon.jpg]: /images/20220610/8926261ba1de49a8b2a2c24775097e6a.png
[arrow_triangle_20_down.jpg]: http://static.blog.csdn.net/images/arrow_triangle%20_down.jpg
[arrow_triangle_up.jpg]: /images/20220610/625917d7eba640868b035daca93ca24f.png
[Link 4]: http://blog.csdn.net/qq_37267015/article/category/6667396
[save_snippets_01.png]: /images/20220610/d7c26a5e673a496f9d5fa1d2cde10f9a.png
[save_snippets.png]: /images/20220610/fe8e8a7b5e3a4c02ba2c83ac94e8a115.png