【设计模式】抽象工厂模式

类图

相较于工厂模式是生产单个类，抽象工厂的作用是生产一个更加复杂的类，这个复杂的类是由多个类组成的，而这些类又有多种实现方法，抽象共产的目的是为了解决生产多个属于同一产品下的不同类的问题

工程目录

代码

AbstractFactory.java

package com.company.pattern.demo11;

/**
 * 抽象工厂：里面应该包含所有的产品创建的抽象方法
 * @author blazar
 */
public abstract class AbstractFactory {
    /**
     * 创建产品A
     * @return AbstractProductA
     */
    public abstract void createProductA();
    /**
     * 创建产品B
     * @return AbstractProductB
     */
    public abstract void createProductB();
}

AbstractProductA.java

package com.company.pattern.demo11;

/**
 * 抽象产品A：可能有多种不同的实现
 * @author blazar
 */
public abstract class AbstractProductA {
    /**
     * 创建产品A
     */
    public abstract void createProductA();
}

AbstractProductB.java

package com.company.pattern.demo11;

/**
 * 抽象产品B：可能有多种不同的实现
 * @author blazar
 */
public abstract class AbstractProductB {
    /**
     * 创建产品B
     */
    public abstract void createProductB();
}

ProductA1.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ProductA1 extends AbstractProductA{
    @Override
    public void createProductA() {
        System.out.println("产品A1");
    }
}

ProductA2.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ProductA2 extends AbstractProductA{
    @Override
    public void createProductA() {
        System.out.println("产品A2");
    }
}

ProductB1.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ProductB1 extends AbstractProductB{
    @Override
    public void createProductB() {
        System.out.println("产品B1");
    }
}

ProductB2.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ProductB2 extends AbstractProductB{
    @Override
    public void createProductB() {
        System.out.println("产品B2");
    }
}

ConcreteFactoryA.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ConcreteFactoryA extends AbstractFactory{
    @Override
    public void createProductA() {
        AbstractProductA abstractProductA = new ProductA1();
        abstractProductA.createProductA();
    }

    @Override
    public void createProductB() {
        AbstractProductB abstractProductB = new ProductB1();
        abstractProductB.createProductB();
    }
}

ConcreteFactoryB.java

package com.company.pattern.demo11;

/**
 * @author blazar
 */
public class ConcreteFactoryB extends AbstractFactory{
    @Override
    public void createProductA() {
        AbstractProductA abstractProductA = new ProductA2();
        abstractProductA.createProductA();
    }

    @Override
    public void createProductB() {
        AbstractProductB abstractProductB = new ProductB2();
        abstractProductB.createProductB();
    }
}

测试类 Main.java

package com.company.pattern.demo11;

/**
 * 测试类
 * @author blazar
 */
public class Main {
    public static void main(String[] args) {
        // 有多少个具体的产品就对应多少个具体的类，这里可以采用简单工厂优化一下
        // 还可以用反射和配置文件进一步优化
        AbstractFactory abstractFactory = new ConcreteFactoryA();
        abstractFactory.createProductA();
        abstractFactory.createProductB();
    }
}

参考《大话设计模式》