设计模式之三——工厂方法模式（Factory Method）&抽象工厂模式（AbstractFacotry）

模式名称

工厂方法模式（Factory Method）、抽象工厂模式（AbstractFacotry）

问题

客户类不关心使用哪个具体类，只关心该接口所提供的功能。

创建过程比较复杂，例如需要初始化其他关联资源，读取配置文件等。

接口有很多具体实现或者抽象类有很多具体子类，避免客户端写一大堆if-else逻辑来决定运行时使用哪个具体实现或者具体子类。

不希望给客户程序暴露过多此类的内部结果或创建过程，降低耦合度。

优化性能，比如缓存大对象或者初始化比较耗时的对象。

GOF为工厂方法模式给出的定义：

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

为创建对象定义一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟至子类。

用法分类

实例一、简单工厂：

//--------------参数化简单工厂创建示例--------------------------
public class ProductCreator {
Product createProduct(String type){
if(type.equals("tv")){
return new TVProduct();
}else if(type.equals("watch")){
return new WatchProduct();
}
}
}

public interface Product{}
public class TVProduct implements Product{}
public class WatchProduct implements Product{}
//---------------工厂的客户类示例----------------------------
public class Client{
private ProductCreator creator;
public Client(ProductCreator creator){
this.creator=creator;
}
public void doSomething(String type){
Product product=creator.createPorduct(type);
//to do something...
}
}
//--------------测试工厂方法---------------------------------
public class TestFacotry{
public static void main(String[] args){
Client client=new Client(new ProductCreator());
client.doSomething("car");
}
}

简单工厂并不是一个模式，只是一种习惯用法。它看起来像是把问题从一个类转移到了另一类，也就是把创建对象的行为从一个类转移到另一个类当中。但它也有其好处，例如，如果有其他客户也需要创建对象，那么就可以直接调用简单工厂，避免代码重复。

实例二、静态工厂方法

静态工厂方法同样不是一种模式，但它可以避免简单工厂类的泛滥，不需要额外的工厂类了。例如，在Java5版本里，为创建基本类型Integer、Long、Boolean对象都提供了静态工厂方法，以Integer为例：

public static Integer valueof(int i){  //注意static关键字
if(i>=-128 && i<=IntegerCache.high)
return IntegerCache.cache[i+128];
else
return new Integer(i);
}

静态工厂方法的优缺点：

优点：

可以为静态工厂选择合适的命名，提高程序的可读性。

静态工厂和简单工厂一样，可以封装复杂的初始化过程。

避免了简单工厂类泛滥

缺点：

一般为了强迫使用工厂方法，我们会让类只含有私有构造方法，这样，会导致此类不能被子类化。

如果添加了一个新的该类的子类，此静态工厂方法可能需要重写，以加入该子类的实例化过程，导致扩展性不强。

静态方法没有面向对象的特征，比如继承、动态多态等，不能被重写。

实例三、真正的模式之一：工厂方法模式

所有的工厂模式都用来封装对象的创建。工厂方法模式（Facotry Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

/**
* 工厂方法模式.
* 工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
* 工厂方法将类的实例化推迟到子类,
*
*/
public abstract class PizzaStore {
public Pizza orderPizza(){
Pizza pizza;

pizza=createPizza(); //不变的部分调用变化的部分

pizza.prepare();
pizza.cut();
pizza.box();
return pizza;
}

protected abstract Pizza createPizza();//变化的部分，工厂方法，由子类实现
}
//-------------------------------------------------------------------------
/**
* 实现了工厂方法。
*/
public class NewYorkPizzaStore extends PizzaStore{
@Override
protected Pizza createPizza() { //工厂方法的实现，创建类的对象。
return new NewYorkPizza();
}
}

实例四、真正的模式之二：抽象工厂模式

定义

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类

。

/**
* 抽象工厂，使用组合创建了一些列产品的集合。
*/
public interface PizzaIngredientFacotry { //接口中，每一种原料都有一个方法创建该原料。
public Sauce createSauce();
public Cheese createChesse();
}
//----------------------------------------------------------
/**
* 抽象工厂PizzaIngredientFactory的一种实现
* @see PizzaIngredientFacotry
*/
public class NYPizzaIngredientFacotry {
public Sauce createSauce(){ //返回具体的酱汁
return new NYSauce();
}
public Cheese createChesse(){
return new NYChesse();
}
}

实际上，抽象工厂的每个方法实际上看起来都像是工厂方法。每个方法都被声明成抽象的，而子类的方法覆盖这些方法来创建某些对象。没错，工厂方法潜伏在抽象工厂里面。抽象工厂的方法经常以工厂方法的方式实现。

抽象工厂的任务是创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品。所以，在抽象工厂中利用工厂方法实现生产方法是相当自然的做法。

与工厂方法的区别

两者都是负责创建对象，但工厂方法使用的是继承，而抽象工厂使用的是对象的组合。

工厂方法适合创建一类对象，即这类对象有共同的抽象。而抽象工厂适合把一组相关的产品集合起来，因为它用的是组合。

对工厂方法来说，抽象创建者中所实现的代码通常会用到子类所创建的具体类型。

当我们需要创建产品家族和想让制造的相关产品集合起来时，就可以使用抽象工厂。

工厂方法的使用方式很简单，只要继承父类，在子类中实现其抽象方法即可。

效果

工厂模式让我们把对象实例化的过程进行了封装，屏蔽了复杂的构建过程。同时，工厂模式让客户类和具体类型解耦，增强了程序的可扩展性和可维护性。只有在需要考虑扩展性的时候才使用工厂方法模式，否则会增加代码的复杂程度。