面向对象：工厂方法（Factory Method）模式

以下内容来自http://www.lifevv.com/sysdesign/index.html

本文介绍设计模式中的工厂方法（Factory Method）模式的概念，用法，以及实际应用中怎么样使用Factory Method模式进行开发。
<script type="text/javascript"> </script> <script src="http://www.adeeee.com/JS/base.js" type="text/javascript"></script> <script src="http://www.adeeee.com/Link.aspx?WebCode=20090621093833&AdCode=20090617042710&AdSize=20090617050144&AdType=10&Os=Windows&Browser=FireFox&Page=http://www.lifevv.com/sysdesign/doc/20071106180002526.html&Tilte=%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8BFactory%20Method%E3%80%80-%20%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F%20-%20%E7%B3%BB%E7%BB%9F%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%BB%BA%E6%A8%A1"></script>

Factory Method模式的概念

在大规模的系统开发过程中，考虑系统的灵活性，低耦合性，可扩展性等因素，常常不直接使用new来生成类的实例，而是通过一个叫做工厂（Factory） 的类来专门生成类的实例。Factory Method模式，在上述基础上，把类的实例生成的任务委让给子工厂去完成的一种设计方法，所以Factory Method模式又被称为多态工厂(Polymorphic Factory)模式。在Factory Method模式中，父工厂类只定义创建对象的公共接口，而子工厂类则负责生成具体的类的实例。
简单一点说，Factory Method模式就是生成类实例（对象）的一种方法。

Factory Method用到以下几个概念：
- 父工厂类：定义创建类实例的接口
- 子工厂类：实现接口定义，生成具体的类的实例
- 具有继承关系的产品类：由子工厂类创建


下面举例说明。
有一系列的自动车产品Bus（公交车），Truck（卡车）；
它们需要由不同的工厂生产，但具有相同的生产流程。

为了以后扩展其他流水线，比如摩托车，我们需要一种柔软的方案来实现自动车生产的过程。
为了实现这个需求，我们定义了：

CarFactory：定义自动车生产的接口规范。
BusFactory：生产Bus。
TruckFactory：生产Truck。

Car：自动车父类，定义了自动车一些公共的属性与行为。
CarBus：公交车，自动车的一种。
CarTruck：卡车，自动车的一种。


下面我们用Factory Method来实现以上模型。

Factory Method模式的实现范例

工厂类定义：
自动车工厂类CarFactory.java

<script src="http://www.lifevv.com/images/code/js/shCore.js" type="text/javascript"></script> <script type="text/javascript"> </script> <script src="http://www.lifevv.com/images/code/js/shBrushJava.js" type="text/javascript"></script>

1. abstract   class  CarFactory {  
2.     //定义生产自动车生产的接口规范   
3.     public  Car createCar();  
4. }  

abstract class CarFactory {
    //定义生产自动车生产的接口规范
    public Car createCar();
}

生产公交车的工厂类BusFactory.java

1. class  BusFactory  extends  CarFactory {  
2.     public  Car createCar() {  
3.         //生产公交车   
4.         return   new  CarBus();  
5.     }  
6. }  

class BusFactory extends CarFactory {
    public Car createCar() {
        //生产公交车
        return new CarBus();
    }
}

生产卡车的工厂类TruckFactory.java

1. class  TruckFactory  extends  CarFactory {  
2.     public  Car createCar() {  
3.         //生产卡车   
4.         return   new  TruckBus();  
5.     }  
6. }  

class TruckFactory extends CarFactory {
    public Car createCar() {
        //生产卡车
        return new TruckBus();
    }
}

产品类定义：
自动车父类Car.java
为了简单起见，只定义了一个方法返回自动车的种类。

1. public   class  Car {  
2.     public  String getType() {  
3.         return   "Car" ;  
4.     }  
5. }  

public class Car {
    public String getType() {
        return "Car";
    }
}

公交车类CarBus.java

1. public   class  CarBus  extends  Car {  
2.     public  String getType() {  
3.         return   "Bus" ;  
4.     }  
5. }  

public class CarBus extends Car {
    public String getType() {
        return "Bus";
    }
}

卡车类CarTruck.java

1. public   class  CarTruck  extends  Car {  
2.     public  String getType() {  
3.         return   "Truck" ;  
4.     }  
5. }  

public class CarTruck extends Car {
    public String getType() {
        return "Truck";
    }
}

Client调用：通过工厂类生产不同的自动车
Client.java

1. public   class  Client {  
2.     public   static   void  main(String[] args) {  
3.         CarFactory factory = new  BusFactory();  
4.         //生产公交车   
5.         Car bus = factory.createCar();  
6.         System.out.println("生产了："  + bus.getType());  
7.   
8.         factory = new  TruckFactory();  
9.         //生产卡车   
10.         Car truck = factory.createCar();  
11.         System.out.println("生产了："  + truck.getType());  
12.   }  
13. }  

public class Client {
    public static void main(String[] args) {
        CarFactory factory = new BusFactory();
        //生产公交车
        Car bus = factory.createCar();
        System.out.println("生产了：" + bus.getType());

        factory = new TruckFactory();
        //生产卡车
        Car truck = factory.createCar();
        System.out.println("生产了：" + truck.getType());
  }
}

执行Client，输出结果：

C:/FactoryMethod>javac *.java
C:/FactoryMethod>java Client
生产了：Bus
生产了：Truck
C:/FactoryMethod>

我们可以发现，在Client.java里调用时，可以通过共通的父类工厂CarFactory调用同一个createCar()接口方法而取得不同的自动车对象（公交车对象，卡车对象）。
也 就是说，可以通过Factory Method模式在不同的子工厂类生成具有统一界面接口的对象，一方面，可以不用关心产品对象的具体实现，简化和统一Client调用过程；另一方面，可 以让整个系统具有灵活的可扩展性，如上面的例子中，若要扩展生产摩托车的流水线，只要再实现一个摩托车类以及摩托车工厂类就行，而Client的调用方法 完全不需改变。