设计模式之工厂模式总结

1. 工厂方法模式

使用场景

1. 工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，到那时需要慎重考虑是否要增加一个工厂类进行管理，增加代码的复杂度。
2. 需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。
3. 工厂方法模式可以用在异构项目中。
4. 可以使用在测试驱动开发的框架下。

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
下面是工厂方法模式的通用类图：

优点

• 良好的封装性，代码结构清晰
  一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。
• 工厂方法模式的扩展性非常优秀
  在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
• 屏蔽产品类
  这一点非常重要，产品类的实现如何变化，调用者都不需要关系，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。
• 工厂方法模式是典型的解耦框架
  高层模块只需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换父类也没问题。

具体实现

• 抽象产品类

/** * 抽象产品类 * */public abstract class Product {    // 产品类的公共方法    public void method1() {        // 业务处理逻辑        System.out.println("这是所有产品共有的方法！");    }    // 抽象方法    public abstract void method2();}

• 具体产品类

具体产品1

/** * 具体产品类1 *  */public class ConcreteProduct1 extends Product {    @Override    public void method2() {        System.out.println("产生了具体产品一！");    }}

具体产品2

/** * 具体产品类2 *  */public class ConcreteProduct2 extends Product {    @Override    public void method2() {        System.out.println("产生了具体产品二！");    }}

• 抽象工厂类

/** * 抽象工厂类 * */public abstract class Creator {    /**     * 创建一个产品对象，其输入参数类型可以自行设置     * 通常为String、Enum、Class等，当然也可以为空     * @param <T>     * @param c     * @return     */    public abstract <T extends Product> T createProduct(Class<T> c);}

• 具体工厂类

/** * 具体工厂类 *  */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) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IllegalAccessException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (ClassNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        return (T) product;    }}

• 测试类

/** * 客户类 *  */public class testCreator {    /**     * @param args     */    public static void main(String[] args) {        Creator creator = new ConcreteCreator();        Product product1 = creator.createProduct(ConcreteProduct1.class);        Product product2 = creator.createProduct(ConcreteProduct2.class);        /*         * 继续业务处理         */        product1.method1();        product1.method2();        product2.method1();        product2.method2();    }}

2. 抽象工厂模式

使用场景

一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式。

定义

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

通用类图如下：

优缺点

优点：

• 封装性。
  每个产品的实现类不是高层模块要关心的，高层模块只关心抽象和接口，不关心对象是如何创建出来的。
• 产品族内的约束为非公开状态。
  具体的产品族内的约束是在工厂内实现的。

缺点：

• 抽象工厂模式的最大缺点就是产品族扩展非常困难。
  例如增加产品C，也就是说产品家族由原来2个增加到3个，抽象类AbstractFactory要增加一个方法createProductC()，然后两个实现类都要修改。

具体实现

• 抽象产品类

抽象产品类A

/** * 抽象产品类A * */public abstract class AbstractProductA {    public void shareMethod(){        System.out.println("这是共享的产品A方法！");    }    public abstract void doSomething();}

抽象产品类B

/** * 抽象产品类B * */public abstract class AbstractProductB {    public void shareMethod(){        System.out.println("这是共享的产品B方法！");    }    public abstract void doSomething();}

• 具体产品类

具体产品A1

/** * 具体产品类A1 *  */public class ProductA1 extends AbstractProductA {    @Override    public void doSomething() {        System.out.println("这是产品A1");    }}

具体产品A2

/** * 具体产品类A2 *  */public class ProductA2 extends AbstractProductA {    @Override    public void doSomething() {        System.out.println("这是产品A2");    }}

具体产品B1

/** * 具体产品类B1 *  */public class ProductB1 extends AbstractProductB {    @Override    public void doSomething() {        System.out.println("这是产品B1");    }}

具体产品B2

/** * 具体产品类B2 *  */public class ProductB2 extends AbstractProductB {    @Override    public void doSomething() {        System.out.println("这是产品B2");    }}

• 抽象工厂类

/** * 抽象工厂类 * */public abstract class AbstractFactory {    public abstract AbstractProductA createProductA();    public abstract AbstractProductB createProductB();}

• 具体工厂类

具体工厂类1（产生X1系列产品）

/** * 具体工厂类1 *  */public class Factory1 extends AbstractFactory {    @Override    public AbstractProductA createProductA() {        // TODO Auto-generated method stub        return new ProductA1();    }    @Override    public AbstractProductB createProductB() {        // TODO Auto-generated method stub        return new ProductB1();    }}

具体工厂类2（产生X2系列产品）

/** * 具体工厂类2 *  */public class Factory2 extends AbstractFactory {    @Override    public AbstractProductA createProductA() {        // TODO Auto-generated method stub        return new ProductA2();    }    @Override    public AbstractProductB createProductB() {        // TODO Auto-generated method stub        return new ProductB2();    }}

• 测试类

/** * 客户类 *  */public class testAbstractFactory {    /**     * @param args     */    public static void main(String[] args) {        // 定义出两个工厂        AbstractFactory factory1 = new Factory1();        AbstractFactory factory2 = new Factory2();        // 产生A1对象        AbstractProductA a1 = factory1.createProductA();        // 产生A2对象        AbstractProductA a2 = factory2.createProductA();        // 产生B1对象        AbstractProductB b1 = factory1.createProductB();        // 产生B2对象        AbstractProductB b2 = factory2.createProductB();        // 业务处理        a1.shareMethod();        a1.doSomething();        a2.shareMethod();        a2.doSomething();        b1.shareMethod();        b1.doSomething();        b2.shareMethod();        b2.doSomething();    }}