设计模式之创建类模式——抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式。

 

定义：

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

 

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

 

通用类图：

 

通用代码：

/**
 * A抽象产品类
 * @author Administrator
 *
 */
public abstract class AbstractProductA {

    // 每个A产品共有的方法
    public void shareMethod() {
        
    }
    
    // 每个A产品相同的方法，不同实现
    public abstract void doSomething();
    
}

 

/**
 * 产品A1的实现类
 * @author Administrator
 *
 */
public class ProductA1 extends AbstractProductA {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub

    }

}

 

/**
 * 产品A2的实现类
 * @author Administrator
 *
 */
public class ProductA2 extends AbstractProductA {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub

    }

}

 

/**
 * B抽象产品类
 * @author Administrator
 *
 */
public abstract class AbstractProductB {

    // 每个B产品共有的方法
    public void shareMethod() {
        
    }
    
    // 每个B产品相同的方法，不同实现
    public abstract void doSomething();
    
}

 

/**
 * 产品B1的实现类
 * @author Administrator
 *
 */
public class ProductB1 extends AbstractProductB {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub

    }

}

 

/**
 * 产品B2的实现类
 * @author Administrator
 *
 */
public class ProductB2 extends AbstractProductB {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub

    }

}

 

/**
 * 抽象工厂类
 * @author Administrator
 *
 */
public abstract class AbstractFactory {

    // 创建A产品家族
    public abstract AbstractProductA createProductA();
    
    // 创建B产品家族
    public abstract AbstractProductB createProductB();
    
}

 

/**
 * 产品等级1的实现类
 * 
 * @author Administrator
 * 
 */
public class Factory1 extends AbstractFactory {

    // 只生产产品等级为1的A产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    // 只生产产品等级为1的B产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }

}

 

/**
 * 产品等级2的实现类
 * 
 * @author Administrator
 * 
 */
public class Factory2 extends AbstractFactory {

    // 只生产产品等级为2的A产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    // 只生产产品等级为2的B产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }

}

 

/**
 * 场景类
 * 
 * @author Administrator
 * 
 */
public class Client {

    /**
     * @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();

        // 业务处理
    }

}

 

抽象工厂模式的优点：

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

 

抽象工厂模式的缺点：

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

 

抽象工厂模式的使用场景：

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

 

抽象工厂模式的注意事项：

抽象工厂模式的缺点是产品族扩展比较困难，但是不是产品的等级。

抽象工厂模式的产品等级非常容易扩展，增加一个产品等级，只要增加一个工厂类负责新增加出来的产品生产任务即可。也就是说横向扩展容易，纵向扩展困难。

转载于:https://www.cnblogs.com/muzongyan/archive/2010/08/19/1803761.html