抽象工厂

一、概述

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

与工厂模式相比:

抽象工厂模式是在工厂模式上面再封装了一层，工厂模式的工厂是直接创建的，而抽象工厂是采用工厂模式创建对象的方法，在工厂模式的基础上把工厂的创建也封装起来。

二、使用

示例：

package pattern.abstractFactory;

/**
 * 抽象工厂模式
 *      创建其他工厂的工厂
 * @author zls
 * @date 2020/3/27
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        FactoryProducer factoryProducer = new FactoryProducer();
        // 从抽象工厂中获取到工厂，而工厂模式直接是自己创建的
        AbstractFactory car = factoryProducer.getFactory("car");
        AbstractFactory color = factoryProducer.getFactory("color");

        // 从工厂中获取不同类型的对象
        Car benz = car.getCar("benz");
        Car bmw = car.getCar("bmw");
        benz.run();
        bmw.run();

        Color red = color.getColor("red");
        Color green = color.getColor("green");
        red.fill();
        green.fill();
    }
}

/**
 * 公共接口
 */
interface Car {
    void run();
}

class Benz implements Car {
    @Override
    public void run() {
        System.out.println("大奔跑得快...");
    }
}

class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("宝马跑得稳...");
    }
}

interface Color {
    void fill();
}

class Red implements Color {
    @Override
    public void fill() {
        System.out.println("填充红色...");
    }
}

class Green implements Color {
    @Override
    public void fill() {
        System.out.println("填充绿色...");
    }
}

/**
 * 工厂的父类：为了有一个统一的接口，当然这里也可以是一个接口
 */
abstract class AbstractFactory {
    abstract Car getCar(String car);
    abstract Color getColor(String color);
}

/**
 * 创建汽车工厂
 */
class CarFactory extends AbstractFactory{
    @Override
    public Car getCar(String type) {
        if (type.equalsIgnoreCase("benz")) {
            return new Benz();
        } else if (type.equalsIgnoreCase("bmw")) {
            return new Bmw();
        }
        return null;
    }

    @Override
    Color getColor(String color) {
        return null;
    }
}

/**
 * 颜色工厂
 */
class ColorFactory extends AbstractFactory {
    @Override
    Car getCar(String car) {
        return null;
    }

    @Override
    Color getColor(String color) {
        if (color.equalsIgnoreCase("red")) {
            return new Red();
        } else if (color.equalsIgnoreCase("green")) {
            return new Green();
        }
        return null;
    }
}

/**
 * 核心：抽象工厂，创建其他工厂的工厂
 * 创建一个工厂创造器/生成器类
 */
class FactoryProducer {
    public static AbstractFactory getFactory(String factory) {
        if (factory.equalsIgnoreCase("car")) {
            return new CarFactory();
        } else if (factory.equalsIgnoreCase("color")) {
            return new ColorFactory();
        }
        return null;
    }
}

参考：

抽象工厂模式