抽象工厂模式

一、简单代码描述

抽象工厂模式定义：

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.(为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。)

---

• 抽象产品A类

package factorypattern.abstractfactory;public abstract class AbstractProductA {    public void shareMethod() {        System.out.println("这是A产品共有的特点");    }    // 具体A产品的具体方法    public abstract void something();}

• 具体产品A1类

package factorypattern.abstractfactory;public class ProductA1 extends AbstractProductA {    @Override    public void something() {        // TODO Auto-generated method stub        System.out.println("生产A1产品");    }}

• 具体产品A2类

package factorypattern.abstractfactory;public class ProductA2 extends AbstractProductA {    @Override    public void something() {        // TODO Auto-generated method stub        System.out.println("生产A2产品");    }}

• 抽象产品类B

package factorypattern.abstractfactory;public abstract class AbstractProductB {    public void shareMethod() {        System.out.println("这是B产品共有的特点");    }    // 具体B产品的具体方法    public abstract void something();}

• 具体产品B1类

package factorypattern.abstractfactory;public class ProductB1 extends AbstractProductB {    @Override    public void something() {        // TODO Auto-generated method stub        System.out.println("这是生产B1产品");    }}

• 具体产品B2类

package factorypattern.abstractfactory;public class ProductB2 extends AbstractProductB {    @Override    public void something() {        // TODO Auto-generated method stub        System.out.println("这是生产B2产品");    }}

• 抽象工厂类

package factorypattern.abstractfactory;public abstract class AbstractCreator {    public abstract AbstractProductA createProductA();    public abstract AbstractProductB createProductB();}

• 具体等级1工厂

package factorypattern.abstractfactory;public class Creator1 extends AbstractCreator {    @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工厂

package factorypattern.abstractfactory;public class Creator2 extends AbstractCreator {    @Override    public AbstractProductA createProductA() {        // TODO Auto-generated method stub        return new ProductA2();    }    @Override    public AbstractProductB createProductB() {        // TODO Auto-generated method stub        return new ProductB2();    }}

• 客户请求类

package factorypattern.abstractfactory;public class Client {    public static void main(String[] args) {        // TODO Auto-generated method stub        AbstractCreator creator1 = new Creator1();        AbstractCreator creator2 = new Creator2();        AbstractProductA a1 = creator1.createProductA();        AbstractProductA a2 = creator2.createProductA();        a1.something();        a2.something();        System.out.println("==========产品搭配分界线============");        AbstractProductB b1 = creator1.createProductB();        AbstractProductB b2 = creator2.createProductB();        b1.something();        b2.something();    }}

输出结果：
生产A1产品
生产A2产品
==========产品搭配分界线============
这是生产B1产品
这是生产B2产品

抽象工厂模式的通用类图

优缺点分析

优点是具有封装性，所关心的是借口是抽象，不关心具体实现细节；同时各个产品之间的约束条件是非公开的。

缺点是产品族的扩展非常困年，因为它变动了之前的接口，违反了开闭原则。但是产品的等级扩展（或者是相似具有等级的属性）并不困难，只要增加一个该等级的工厂即可，不需要需改之前的接口定义。