JAVA的23种设计模式---抽象工厂模式

概要：

该文章参考了《设计模式之禅》一书及一些前辈的博客文章

1.该文章阐述了抽象工厂模式的原理及展示了抽象工厂模式的通用模板；
2.该文章适合初学设计模式的技术人员研习；
3.该文章有许多不足之处，请各位大咖指正，喷子绕道；

正文：

抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

1.通用抽象工厂模式模板代码实现：

抽象产品类

/**
 * 抽象产品
 * @author Administrator
 *
 */
public interface Product {
    //产品
    public void doSomethingAboutProduct();
}

/**
 * 抽象的A产品
 * @author Administrator
 *
 */
public abstract class ProductA implements Product {

    @Override
    public abstract void doSomethingAboutProduct();

}

/**
 * 抽象的B产品
 * @author Administrator
 *
 */
public abstract class ProductB implements Product {

    @Override
    public abstract void doSomethingAboutProduct();

}

具体产品类

/**
 * 具体的A产品的“1型号”
 * @author Administrator
 *
 */
public class FirstProductA extends ProductA {

    @Override
    public void doSomethingAboutProduct() {
        System.out.println("产品A1的实现方法");
    }

}

/**
 * 具体的A产品的“2型号”
 * @author Administrator
 *
 */
public class SecondProductA extends ProductA {

    @Override
    public void doSomethingAboutProduct() {
        System.out.println("产品A2的实现方法");
    }

}

/**
 * 具体的B产品的“1型号”
 * @author Administrator
 *
 */
public class FirstProductB extends ProductB {

    @Override
    public void doSomethingAboutProduct() {
        System.out.println("产品B1的实现方法");
    }

}

/**
 * 具体的B产品的“2型号”
 * @author Administrator
 *
 */
public class SecondProductB extends ProductB {

    @Override
    public void doSomethingAboutProduct() {
        System.out.println("产品B2的实现方法");
    }

}

抽象工厂类

/**
 * 抽象工厂
 * @author Administrator
 *
 */
public interface AbstractFactory {
    //用于生产相同型号的A产品
    public ProductA createProductA();
    //用于生产相同型号的B产品
    public ProductB createProductB();

}

/**
 * 抽象A工厂
 * @author Administrator
 *
 */
public abstract class AbstractFactoryA implements AbstractFactory {

    @Override
    public abstract ProductA createProductA();

    @Override
    public abstract ProductB createProductB();

}

/**
 * 抽象B工厂
 * @author Administrator
 *
 */
public abstract class AbstractFactoryB implements AbstractFactory {

    @Override
    public abstract ProductA createProductA();

    @Override
    public abstract ProductB createProductB();

}

具体工厂类

/**
 * 具体的A工厂，只出产“1”型号
 * @author Administrator
 *
 */
public class FactoryA extends AbstractFactoryA {
    //出产型号为1的A产品
    @Override
    public ProductA createProductA() {
        return new FirstProductA();
    }
    //出产型号为1的B产品
    @Override
    public ProductB createProductB() {
        return new FirstProductB();
    }

}

/**
 * 具体的B工厂，只出产“2”型号
 * @author Administrator
 *
 */
public class FactoryB extends AbstractFactoryB {
    //出产型号为2的A产品
    @Override
    public ProductA createProductA() {
        return new SecondProductA();
    }
    //出产型号为2的B产品
    @Override
    public ProductB createProductB() {
        return new SecondProductB();
    }

}

模拟生产

/**
 * 模拟工厂生产，测试类
 * @author Administrator
 *
 */
public class Production {
    public static void main(String[] args) {
        //A工厂生产出同型号为“1”的A、B产品
        //输出“产品A1的实现方法”
        new FactoryA().createProductA().doSomethingAboutProduct();
        //输出“产品B1的实现方法”
        new FactoryA().createProductB().doSomethingAboutProduct();

        //B工厂生产出同型号为“2”的A、B产品
        //输出“产品A2的实现方法”
        new FactoryB().createProductA().doSomethingAboutProduct();
        //输出“产品B2的实现方法”
        new FactoryB().createProductB().doSomethingAboutProduct();
    }
}

注：模板代码中模拟了“A”、“B”2个厂，模拟了“A1”、“B1”、“A2”、“B2”4种产品，其中“A1”、“B1”两种产品拥有相同的型号“1”，“A2”、“B2”两种产品拥有相同的型号“2”，相同型号的产品需放到同一家工厂才能提高生产效率，“型号”即为对象的关联方式。