工厂模式（Factory）

在面向对象的编程中，工厂模式是一种经常被使用到的模式。总的来说，在工厂模式里，如果有一个公共的抽象父类，该父类派生出一组子类。那么在创建不同的子类时，把任务交给一个工厂类，由它选择生成哪个子类实例，即用户只需要传递必要的参数给工厂类就可以了，而不去关心具体的子类是怎样产生的。

根据工厂类的不同，工厂模式分3种：

1.简单工厂(Simple Factory)模式；
2.工厂方法(Factory Method)模式，又称多形性工厂(Polymorphic Factory)模式；
3.抽象工厂(Abstract Factory)模式，又称工具箱(Kit或Toolkit)模式。
　　
下面我们就来详细讨论：

1 简单工厂

先来讲下简单工厂模式。一个简单工厂模式根据所提供的数据返回某个父类的一个子类实例。为了方便理解，我写了下面的例子：

//父类
abstract class Fruit {
      protected String fruitName;
     protected int price;
}

//子类1
public class Apple extends Fruit {
     public Apple(){
          fruitName="Apple";
          price=2;
     }
}

//子类2
public class Pear extends Fruit {
     public Pear(){
          fruitName="Pear";
          price=1;
     }
}

//工厂类 —— 用于产生子类的实例
public class Gardener {
     public static Fruit getFruit(String fruitName){
          if (fruitName.equals("apple")){
               return new Apple();
          }
          else if (fruitName.equals("pear")){
               return new Pear();
          }
          else{
               System.out.println("Not have the fruit!");
               System.exit(0);
          }
          return null;
     }
}

//测试类 —— 使用工厂产生子类的实例
public class Test {
     public static void main(String[] args) {
          Fruit f1=Gardener.getFruit("apple");
          Fruit f2=Gardener.getFruit("pear");
          System.out.println("The price is:");
          System.out.println(f1.fruitName+":"+f1.price);
          System.out.println(f2.fruitName+":"+f2.price);  
     }
}

结果如下：
　　The price is:
　　Apple:2
　　Pear:1

看到没？要找水果的话只需找工厂，也就是告诉园丁（Gardener）要找的水果名称就可以了，具体怎么找就不用管了，园丁会帮你找到的。
　　
在简单工厂模式中，一个工厂类处于对产品类（父类）实例化的中心位置上，它知道每一个产品（子类），它决定哪一个产品类应当被实例化。这个模式的优点是允许客户端相对独立于产品创建的过程，但是，因为如果有新的产品加入到系统中去，除了增加新产品的实现类，还需要修改工厂类，将必要的逻辑加入到工厂类中。

2 工厂方法

在简单工厂模式内，体现的是大而全，好比由一个大而全的园丁搞定所有的水果。在工厂方法模式中，则是细而多，满足“一个封装最多引入一个可变化的因数”，就是说一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类只能创建一个具体产品类的实例。

工厂方法是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定哪一个产品类应当被实例化，它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，这就是所谓”延迟到子类中实现”，这个决定被交给子类去作。处于工厂方法模式的中心位置上的类甚至都不去接触哪一个产品类应当被实例化这种细节。

在工厂基类中还可以封装生成目标对象所需要的参数变量，在生成工厂子类对象时可以设置这些参数变量，为生成目标对象做好参数准备。通过提供不同的参数变量值来生成不同的工厂子类，这可以通过简单工厂方式实现，在这个简单工厂类中可以实现决策点，只是这个简单工厂返回的还是一个工厂子类，这个工厂子类可以进而生成目标对象。

拿上面的例子来说，有个园丁总管，下面训练了一批小园丁，每个小园丁只管一种水果。你找水果，就直接叫管那种水果的小园丁去，园丁总管甚至可以不知道是哪个小园丁去找水果了。

下面是一些解释性代码：

public interface GardenerDirector {
     public Fruit getFruit();
}

public class GardenerOfApple implements GardenerDirector {
     public Fruit getFruit(){
          return new Apple();
     }
}

public class GardenerOfPear implements GardenerDirector {
     public Fruit getFruit(){
          return new Pear();
     }
}

后面具体再怎么做我就不再写了。

工厂方法模式可以允许系统在不修改工厂类（无论是工厂父类还是工厂子类）的情况下增加新产品，即符合开－闭原则，只要没有包含简单工厂模式的应用。下面，我们再来看一个例子。

新建赛车的接口：

package car_interface;
public interface Icar_interface {
     public void start();
     public void stop();
}

新建1个汽车信息的基类：

package car_imple;
import car_interface.Icar_interface;
public class base_car_imple implements Icar_interface {
     private int speed;
     private String name;
     public int getSpeed() {
          return speed;
     }
     public void setSpeed(int speed) {
          this.speed = speed;
     }
     public String getName() {
          return name;
     }
     public void setName(String name) {
          this.name = name;
     }
     public void start() {
          // TODO Auto-generated method stub
     }
     public void stop() {
          // TODO Auto-generated method stub
     }
}
　　　　
新建奥迪汽车实现类：

package car_imple;
import car_interface.Icar_interface;
public class car_audi_imple extends base_car_imple {
     public void start() {
          System.out.println(this.getName() + " 车以专利技术起动了　最高速度为："
          + this.getSpeed());
     }
     public void stop() {
          System.out.println(this.getName() + " 车以专利技术停车了");
     }
}

新建大众汽车实现类：

package car_imple;
import car_interface.Icar_interface;
public class car_3w_imple extends base_car_imple {
     public void start() {
          System.out.println(this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
     }
     public void stop() {
          System.out.println(this.getName() + " 车以专利技术停车了");
     }
}

新建一个汽车工厂接口：

package car_factory_interface;
import car_interface.Icar_interface;
public interface Icar_factory {
     public Icar_interface create_car();
}

新建一个创建奥迪车的汽车工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_audi_imple;
import car_interface.Icar_interface;

public class audi_car_factory_imple implements Icar_factory {
     public Icar_interface create_car() {

          car_audi_imple car_audi_imple_ref = new car_audi_imple();
          car_audi_imple_ref.setName("奥迪A6");
          car_audi_imple_ref.setSpeed(300);

          return car_audi_imple_ref;
     }
}

新建一个创建大众车的汽车工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple;
import car_imple.car_audi_imple;
import car_interface.Icar_interface;

public class threeW_car_factory_imple implements Icar_factory {
     public Icar_interface create_car() {

          car_3w_imple car_3w_imple_ref = new car_3w_imple();
          car_3w_imple_ref.setName("大众A6");
          car_3w_imple_ref.setSpeed(400);

          return car_3w_imple_ref;
     }
}

客户端运行程序代码：

package run_main;

import car_factory_imple.audi_car_factory_imple;
import car_factory_interface.Icar_factory;
import car_interface.Icar_interface;

public class run_main {
     public static void main(String[] args) {

          Icar_factory car_factory = new audi_car_factory_imple();
          Icar_interface car_ref = car_factory.create_car();
          car_ref.start();
          car_ref.stop();
    }
}

程序运行结果如下：

奥迪A6 车以专利技术起动了　最高速度为：300
奥迪A6 车以专利技术停车了

通过使用工厂方法模式就可以将对象的创建延迟到子类进行实例化，而且每个工厂创建不同的品牌的汽车，每个汽车的功能都有自己“专利”的实现，这样可以将不同“品牌”的“汽车”的创建进行分类，有利于对象创建的清晰性。创建不同的汽车只需要改动这句代码就可以了：

Icar_factory car_factory = new threeW_car_factory_imple();

3 抽象工厂

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态，主要是用来解决具体产品是有几类产品族的问题，所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。

刚才介绍工厂方法的使用，从那个程序中可以看到，奥迪audi车是从audi_car_factory_imple工厂中创建出来的，而大众3W车是从 threeW_car_factory_imple工厂中创建出来的，那么如果这2家汽车生产大厂由总部在北京市，现在发展到上海，深圳等城市创建生气汽车的分厂，该怎么办？是不是得将原来的奥迪汽车工厂类：

public class audi_car_factory_imple implements Icar_factory {
     public Icar_interface create_car() {
          car_audi_imple car_audi_imple_ref = new car_audi_imple();
          car_audi_imple_ref.setName("奥迪A6");
          car_audi_imple_ref.setSpeed(300);

          return car_audi_imple_ref;
     }
}

改成类似如下的模样：

public class audi_car_factory_imple implements Icar_factory {
     public Icar_interface create_car(String area_car) {
          if (area_car.equals("北京")){创建一个北京的奥迪汽车....}
          if (area_car.equals("上海")){创建一个上海的奥迪汽车....}
          if (area_car.equals("深圳")){创建一个深圳的奥迪汽车....}

          return car_audi_imple_ref;
     }
}

那么发现一个问题，不同地域的汽车却在一个工厂中出现，这是不合乎常理的，因为北京奥迪在北京分厂创建，上海奥迪在上海分厂创建，这样才对。

所以如果遇到分“大系”来创建对象的时候，抽象工厂方法是肯定要使用的时候了。这里的大系指的就是从地域上来分。

这个例子就应该以“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”

比如在玩“极品飞车”这款游戏，每个地图处都有造车的工厂，每个造车的工厂都因为有造车的档次不同而划分为高级车厂，低级车厂，那么这样的场景正是应用抽象工厂的好时机，再来理解一下这句话“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”，用抽象造车工厂来定义具体造车工厂的抽象，而由具体的造车工厂来创建汽车，这就是抽象工厂与工厂方法的不同，工厂方法中对象的创建是由工厂方法来确定的，创建的对象都是不分类并且实现一个接口的，而抽象工厂就是在工厂方法的基础上对创建车的对象的行为进行分类，比如北京车厂，上海车厂等。

来，进入抽象工厂模式，对普通车和高级车进行分类（有兴趣的朋友可以加上北京或上海这样不同的大系再进一步细分）：

新建汽车接口：
package car_interface;
public interface Icar_interface {
     public void start();
     public void stop();
}

新建汽车父类：

package car_imple;
import car_interface.Icar_interface;
public class base_car_imple implements Icar_interface {
     private int speed;
     private String name;

     public int getSpeed() {
          return speed;
     }

     public void setSpeed(int speed) {
          this.speed = speed;
     }

     public String getName() {
          return name;
     }

     public void setName(String name) {
          this.name = name;
     }

     public void start() {
          // TODO Auto-generated method stub
     }

     public void stop() {
          // TODO Auto-generated method stub
     }
}

新建大众高级车：

package car_imple;
import car_interface.Icar_interface;
public class car_3w_imple_adv extends base_car_imple {

     public void start() {
          System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
     }

     public void stop() {
          System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
     }
}

新建大众普通车：

package car_imple;
import car_interface.Icar_interface;
public class car_3w_imple_low extends base_car_imple {
     public void start() {
          System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
     }

     public void stop() {
          System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
     }
}

新建奥迪高级车：

package car_imple;
import car_interface.Icar_interface;
public class car_audi_imple_adv extends base_car_imple {

     public void start() {
          System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
     }

     public void stop() {
          System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
     }
}
新建奥迪普通车：

package car_imple;
import car_interface.Icar_interface;
public class car_audi_imple_low extends base_car_imple {
     public void start() {
          System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
     }
     public void stop() {
          System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
     }
}

新建抽象工厂接口（我们看到，与工厂方法不同，抽象工厂将同系不同类的方法抽象成了接口）：

package car_factory_interface;
import car_interface.Icar_interface;
public interface Icar_factory {
     public Icar_interface create_threeW_car();
     public Icar_interface create_audi_car();

}

新建抽象工厂接口的高级车adv工厂实现类（你也可以改成北京工厂，深圳工厂……）：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_adv;
import car_imple.car_audi_imple_adv;
import car_interface.Icar_interface;

public class car_factory_adv implements Icar_factory {

     public Icar_interface create_audi_car() {

          car_audi_imple_adv car_audi_imple_adv = new car_audi_imple_adv();
          car_audi_imple_adv.setName("奥迪A6");
          car_audi_imple_adv.setSpeed(300);

          return car_audi_imple_adv;
     }

     public Icar_interface create_threeW_car() {
        
          car_3w_imple_adv car_3w_imple_adv_ref = new car_3w_imple_adv();
          car_3w_imple_adv_ref.setName("大众A6");
          car_3w_imple_adv_ref.setSpeed(300);

          return car_3w_imple_adv_ref;
     }
}

新建抽象工厂接口的普通车low工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_low;
import car_imple.car_audi_imple_low;
import car_interface.Icar_interface;

public class car_factory_low implements Icar_factory {

     public Icar_interface create_audi_car() {

          car_audi_imple_low car_audi_imple_low_ref = new car_audi_imple_low();
          car_audi_imple_low_ref.setName("奥迪A6");
          car_audi_imple_low_ref.setSpeed(300);

          return car_audi_imple_low_ref;
     }

     public Icar_interface create_threeW_car() {
        
          car_3w_imple_low car_3w_imple_low_ref = new car_3w_imple_low();
          car_3w_imple_low_ref.setName("大众A6");
          car_3w_imple_low_ref.setSpeed(300);

          return car_3w_imple_low_ref;
     }
}

新建客户端运行类：

package run_main;
import car_factory_imple.car_factory_adv;
import car_factory_interface.Icar_factory;
import car_interface.Icar_interface;
public class run_main {
     public static void main(String[] args) {

     Icar_factory Icar_factory_ref = new car_factory_adv();

     Icar_interface Icar_interface_ref = Icar_factory_ref
                .create_threeW_car();
     Icar_interface_ref.start();
     Icar_interface_ref.stop();
    }
}

程序运行结果如下：

富华版：大众A6 车以专利技术起动了　最高速度为：300
富华版：大众A6 车以专利技术停车了

 

从程序中可以看到工厂方法属于类型创建模式，而抽象工厂属于对象创建模式，并且所谓的类创建模式就是把创建工作延迟到子类，而对象创建模式则将延迟到另一个对象。类模式处理类和子类子间的关系，这些关系通过继承建立，是静态的，在编译时刻便确定下来。对象模式则处理对象之间的关系，是动态的，运行时刻是可以变化的，更具动态性。

 

工厂是抽象的，工厂的实现是不样的，不同的工厂创建出不同汽车。而工厂方法仅仅是用一个工厂去创建很多汽车。

最后抓一篇阎宏的小文字来结束本博：

一开始只在后花园中种蔬菜类的时候可以用简单工厂模式，由工厂负责生成具体的蔬菜类，

但是如果后花园要引进水果类的时候简单模式就行不通了，因此需要使用工厂方法模式，将产品类族分开。

但是如果后花园的规模继续扩大到地域范围的分割时，比如说一个在北京，一个在上海的时候，工厂方法模式就不够了，因为对两个后花园来说，每个后花园的植物是要被种在一起的，并且两个后花园用工厂方法模式是无法体现其区别的。