"围观"设计模式(8)--创建型之简单工厂模式、工厂方法模式、抽象工厂模式

工厂模式的核心思想在我认为是将类创建的权利授予给工厂类，其他的类不允许创建，授予了权限的类创建好之后，需要某些的对象的时候，可以去工厂当中去取。也就是像一个工厂一样，用的人不需要关心对象怎么来的，你只需要关心怎么用就好了。工厂模式细分为三种，简单工厂、工厂方法、抽象工厂三种模式。这三种模式比较相似，往往会引发混淆，本文主要结合实际的例子去进行区分。理清三者之间的关系与适用范围。

概述

简单工厂

对于简单工厂，我个人的理解是，直接实现一个方法，要生产什么由这个方法以及传入的参数来决定。

工厂方法

1. 解决了哪类“工厂”生产哪类东西的问题。

2. 这种模式通过公共的接口或抽象类定义生产出来的是哪种东西，但是不限制生产出来的具体产品，在其子类中或者实现类中去确定具体生产出来的是什么东西。

抽象工厂

1. 解决了同一种东西多种分类的情况。

2. 抽象类去设定生产的产品的具体分类，交给子类去实际生产该分类下的产品。

简单的讲，三者最主要的区别在于：

简单工厂：通过参数控制生产的不同的产品。

工厂方法：通过不同的子类工厂生产不同的产品。

抽象工厂：通过方法生产不同的产品。

简单工厂模式

采用简单工厂模式，在Factory实现类中直接，createCar的时候，传入想要创建的Car的名称，然后在这个方法里面对传入的名称进行区分创建对应的对象并返回，当然这个是比较简单的形式。

核心的代码如下（全部的代码我会上传到个人的GitHub上：下载地址）

[java] view plain copy

1. @Override  
2.     public Car createCar(String carName) {  
3.         Car car = null;  
4.         if("HongQI".equals(carName)){  
5.             car = new HongQi();  
6.         }else if("BYD".equals(carName)){  
7.             car = new BYD();  
8.         }  
9.           
10.         return car;  
11.     }  

采用泛型使得实际具有灵活性，核心代码如下（全部的代码我会上传到个人的GitHub上：下载地址）：

[java] view plain copy

1. @Override  
2.     public <T extends Car> T createCar(Class<T> clazz) {  
3.         Car car = null;  
4.         if(clazz != null){  
5.             try {  
6.                 car = (Car)Class.forName(clazz.getName()).newInstance();  
7.             } catch (Exception e) {  
8.                 e.printStackTrace();  
9.             }   
10.         }  
11.         return (T) car;  
12.     }  

在我看来，简单工厂模式通过参数的类型进行创建不同的对象，也就是相当于根据传入的参数生产不同的产品。当然，使用泛型后弱化了 这种特征（但是使用泛型后使得这个工厂更具有灵活性，只需要传入想创建的那个类就可以了，对需求变更的情况更有适应性），请结合第一个例子进行体会。

工厂方法模式

工厂方法模式有点类似于专车的样子，我只能生产这个东西，你只能生产那个东西，比较专一。

看下面这个类图：

看上面的类图，应该比较清楚的看到，BYD车由BYDFactory工厂来"生产"，而HongQI车由HongQIFactory工厂来"生产",相当于专车专用的概念。

看部分主要的代码（全部的代码我会上传到个人的GitHub上：下载地址）：

[java] view plain copy

1. public interface Car {  
2.   
3.     public abstract void setCarName(String carName);  
4.       
5.     public abstract void setCarColor(String color);  
6.       
7. }  

[java] view plain copy

1. public interface Factory {  
2.   
3.     public Car createCar();  
4. }  

抽象工厂模式

前面已经提到了，抽象工厂解决了生产一种产品不同类型的产品的问题。

这里通过抽象的工厂类定义了其子类可以生产不同的产品，不同的工厂可以实现生产 不同型号的同一种类的产品。

1. 解决了同一种东西多种分类的情况。

2. 抽象类去设定生产的产品的具体分类，交给子类去实际生产该分类下的产品。

抽象工厂：通过方法生产不同的产品。

下面看一下核心的代码（全部的代码我会上传到个人的GitHub上：下载地址）

[java] view plain copy

1. public abstract class AbstractCarFactory {  
2.   
3.     public abstract HongQI createHongQiCar();  
4.       
5.     public abstract BYD createBYDCar();  
6.       
7. }  

[java] view plain copy

1. </pre><span style="font-size:12px;"></span><pre name="code" class="java">public class FirstGenerFactory extends AbstractCarFactory{  
2.   
3.     @Override  
4.     public HongQI createHongQiCar() {  
5.           
6.         return new HongQiFirst();  
7.     }  
8.   
9.     @Override  
10.     public BYD createBYDCar() {  
11.         return new BYDFirst();  
12.     }  
13.   
14. }  

[java] view plain copy

1. public class SecondGenerFactory extends AbstractCarFactory{  
2.   
3.     @Override  
4.     public HongQI createHongQiCar() {  
5.           
6.         return new HongQiSecond();  
7.     }  
8.   
9.     @Override  
10.     public BYD createBYDCar() {  
11.         return new BYDSecond();  
12.     }  
13.   
14. }  

小结：

简单工厂：用来生产同一等级的任意产品，有点像是上帝类什么都能生产，不过当新的业务需求来了的时候，可能会带来程序的改动，当然当你设计已经考虑好了变动的时候，那可能也是不错的选择。

工厂方法：减轻一个工厂的负担了，一个工厂就生产你自己专有的东西，专一直接，增加生产的东西的时候，只需要增加生产该产品的生产类即可。

抽象工厂：当一个产品有多种类型的时候就需要考虑抽象工厂模式了，比如1系列和2系列的车，那么这个时候，我们可以设计一个只生产1系列的工厂来生产1系列的车，设计2系列的工厂来生产2系列的车。

全部的代码我会上传到个人的GitHub上：下载地址