设计模式：工厂方法模式

定义

工厂方法模式(Factory Method)

定义一个用于创建对象的接口，让子类决定实例化哪一个类。 Factory Method使一个类的实例化延迟到其子类。

从定义中就可以看出这个模式的作用：定义和维护对象之间的关系。
工厂方法模式的适用场景有：

• 当一个类不知道它所必须创建的对象的类的时候。
• 当一个类希望由它的子类来指定它所创建的对象的时候。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类 是代理者这一信息局部化的时候。

它的类图可以参考下图：

其中

• Product —定义工厂方法所创建的对象的接口。
• ConcreteProduct —实现Product接口。
• Creator —声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。也可以调用工厂方法以创建一个Product对象。
• ConcreteCreator —重定义工厂方法以返回一个ConcreteProduct实例

实现

下面通过对代码实现上面描述的工厂方法模式。
根据类图，先定义一个产品的接口。

package com.designpattern.creational.factoryMethod;

/**
 * — 定义工厂方法所创建的对象的接口。
 * Created by mungo on 2017/3/29.
 */
public interface Product {
    public void getProductName();
    public void getProductColor();
}

产品接口Product ，是产品的一个抽象，每个产品定义两个方法，输出产品名称和颜色。
然后定义两个个具体产品ConcreteProductA 和ConcreteProductB。

package com.designpattern.creational.factoryMethod;

/**
 * 实现Product接口。
 * Created by mungo on 2017/3/29.
 */
public class ConcreteProductA implements Product {
    @Override
    public void getProductName() {
        System.out.println("ProductA");
    }

    @Override
    public void getProductColor() {
        System.out.println("ProductA 红色");
    }
}

package com.designpattern.creational.factoryMethod;

/**
 * 实现Product接口。
 * Created by mungo on 2017/3/29.
 */
public class ConcreteProductB implements Product {
    @Override
    public void getProductName() {
        System.out.println("ProductB");
    }

    @Override
    public void getProductColor() {
        System.out.println("ProductB 白色");
    }
}

这样需要的产品就定义好了，可是定义产品最终目的是为了使用，现在产品定义完成剩下的就是如何使用。想象一下，作为一个生产的管理者，如果每生产一个产品都要详细的知道产品的具体内容，这无疑是不 现实的。他应该只需要知道生产的是什么就可以了。所以，生产者应该接收产品的接口的实现类，然后去创建相应对象就好。

package com.designpattern.creational.factoryMethod;

/**
 * 声明工厂方法，该方法返回一个Product类型的对象。
 * Creator也可以定义一个工厂方法的缺省实现，
 * 它返回一个缺省的ConcreteProduct对象。
 * 可以调用工厂方法以创建一个Product对象。
 * Created by mungo on 2017/3/29.
 */
public abstract class Creator {
    public abstract <T extends Product> T createProduct(Class<T> c);
}

这里使用了泛型，这样通过对createProduct的输入参数做了两层限制：

1. 必须为Class类型
2. 必须是Product的实现类
   通过这些约束可以减少类型的转换，同时可以约束其输入参数。
   现在工厂定义好了，我们可以通过继承这个Creator 实现在使用时具体创建哪个类。当然也可以在里面定义一个缺省的实现，这些都是实现上的细节了。

package com.designpattern.creational.factoryMethod;

/**
 * 重定义工厂方法以返回一个ConcreteCreator实例。
 * Created by mungo on 2017/3/29.
 */
public class ConcreteCreator extends Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

这样通过传进来的Class名称就可以直接决定去创建哪个具体的类。
客户端代码如下：

package com.designpattern.creational.factoryMethod;

/**
 * Created by mungo on 2017/3/29.
 */
public class Client {
    public static void main(String[] args){
        Creator factory = new ConcreteCreator();
        Product productA= factory.createProduct(ConcreteProductA.class);
        Product productB= factory.createProduct(ConcreteProductB.class);
        productA.getProductName();
        productA.getProductColor();
        productB.getProductName();
        productB.getProductColor();
    }
}

输出结果：

这样，就实现了上面类图中的工厂方法模式。
可以看出，

工厂方法不再将与特定应用有关的类绑定到你的代码中。代码仅处理Product接口；因此它可以与用户定义的任何ConcreteProduct类一起使用。工厂方法的一个潜在缺点在于客户可能仅仅为了创建一个特定的ConcreteProduct对象，就不得不创建Creator的子类。当Creator子类不必需时，客户现在必然要处理类演化的其他方面；但是当客户无论如何必须创建Creator的子类时，创建子类也是可行的。

应用

工厂方法模式的有点

1. 良好的封装性，同时可以为对象的创建提供一定的约束，使得调用者只需要知道这个对象的名称（或者其他的约束名称）即可。不需要去了解对象的创建过程，这可以降低模块之间的耦合。
2. 扩展性好。如果现在要增加ConcreteProductC,在上面的代码中，只需要定义一个ConcreteProductC类即可。
3. 屏蔽具体实现。就像上面的代码中，调用者无需关心ConcreteProductA，ConcreteProductB如何变化，只要Product的接口不变，调用者的使用方式就不会变化。因为实现类的实例化是由工厂完成的。

所以，工厂方法是典型的解耦框架。高层模块只需要知道抽象，对于其他的实现类都无需关系，这也符合面向对象的迪米特法则，即不需要去交流。同时，对象的创建不再由调用者，而是由框架去完成，调用只依赖具体实现的抽象，也符合依赖倒置原则。
对于工厂方法的应用，首先，工厂方法模式是为了创建对象替换new的一个替换方案，所以在需要创建对象的地方都可以使用，只是需要考虑引入一个工厂类进行管理增加的代码复杂度是否值得。其次，需要灵活可扩展的框架时。因为对于面向对象，一切皆对象。比如设计一个数据库访问的程序，对于不同的数据库就可以采用工厂方法模式，在使用时通过传递不同的数据库区分来决定使用哪个数据库驱动。