设计模式-抽象工厂模式

1.描述

抽象工厂模式、Abstract Factory Pattern。是创建型设计模式的一种，围绕一个超级工厂，来创建其他工厂。

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

使用场景：明确地知道什么情况下创建什么样的实例；为创建一组相关或相互依赖的对象提供一个接口，而且不需要指定它们的具体类。

举个栗子：暂时没想到

优点：基于工厂模式的升级版，多个工厂组合工作的时候可以用抽象工厂，是一个不错的方案。

缺点：产品族扩展困难。

源码在文末

2.代码实现

2.1.工具车产品定义

我们有一个工厂，可以生产工具车。工具车包括坦克、拖拉机、货车。在不同情况下，我们需要不同的工具车。

我们先定义一下我们的工具车

/**
 * 工具车接口
 *
 * @author 编程还未
 */
public interface ToolCar {
    /**
     * 跑起来
     */
    void run();
}

接着定义我们的产品

坦克

/**
 * 坦克
 *
 * @author 编程还未
 */
public class Tank implements ToolCar {
    /**
     * 跑起来
     */
    @Override
    public void run() {
        System.out.println("tank running");
    }
}

拖拉机

/**
 * 拖拉机
 *
 * @author 编程还未
 */
public class Tractor implements ToolCar {
    /**
     * 跑起来
     */
    @Override
    public void run() {
        System.out.println("tractor running");
    }
}

货车

/**
 * 货车
 * @author 编程还未
 */
public class Truck implements ToolCar {
    /**
     * 跑起来
     */
    @Override
    public void run() {
        System.out.println("truck running");
    }
}

2.2.颜色产品定义

我们需要为我们的工具车设置不同的颜色，以满足不同的需求。比如：树林用迷彩绿，沙漠地区用沙子黄，等等。

我们需要一个颜色接口

/**
 * 颜色接口
 *
 * @author 编程还未
 */
public interface Color {
    /**
     * 填充颜色
     */
    void fill();
}

颜色的三个实现类蓝、绿、红

/**
 * 蓝色
 *
 * @author 编程还未
 */
public class Blue implements Color {
    /**
     * 填充颜色
     */
    @Override
    public void fill() {
        System.out.println("Blue fill");
    }
}

/**
 * 绿色
 *
 * @author 编程还未
 */
public class Green implements Color {
    /**
     * 填充颜色
     */
    @Override
    public void fill() {
        System.out.println("Green fill");
    }
}

/**
 * 红色
 *
 * @author 编程还未
 */
public class Red implements Color {
    /**
     * 填充颜色
     */
    @Override
    public void fill() {
        System.out.println("red fill");
    }
}

2.3.定义工厂类

抽象工厂

/**
 * 抽象工厂类
 *
 * @author 编程还未
 */
public abstract class AbstractFactory {
    /**
     * 获取颜色
     *
     * @param type 颜色类型
     * @return 颜色
     */
    public abstract Color getColor(ColorFactory.Type type);

    /**
     * 获取工具车
     *
     * @param type 工具车类型
     * @return 工具车
     */
    public abstract ToolCar getToolCar(ToolCarFactory.Type type);

    enum Type {
        Color, ToolCar;
    }
}

颜色工厂和工具车工厂

/**
 * 颜色工厂
 * <p>
 * 可以生产：蓝色、绿色、红色
 *
 * @author 编程还未
 */
public class ColorFactory extends AbstractFactory {

    /**
     * 获取颜色
     *
     * @param type 颜色类型
     * @return 颜色
     */
    @Override
    public Color getColor(Type type) {
        if (type == null) {
            return null;
        }
        if (Type.BLUE.equals(type)) {
            return new Blue();
        }
        if (Type.GREEN.equals(type)) {
            return new Green();
        }
        if (Type.RED.equals(type)) {
            return new Red();
        }
        return null;
    }

    /**
     * 获取工具车
     *
     * @param type 工具车类型
     * @return 工具车
     */
    @Override
    public ToolCar getToolCar(ToolCarFactory.Type type) {
        return null;
    }

    public enum Type {
        BLUE, GREEN, RED;
    }
}

/**
 * 工具车工厂
 * <p>
 * 可以生产：坦克、拖拉机、货车
 *
 * @author 编程还未
 */
public class ToolCarFactory extends AbstractFactory {


    /**
     * 获取颜色
     *
     * @param type 颜色类型
     * @return 颜色
     */
    @Override
    public Color getColor(ColorFactory.Type type) {
        return null;
    }

    /**
     * 获取工具车
     *
     * @param type 工具车类型
     * @return 工具车
     */
    @Override
    public ToolCar getToolCar(Type type) {
        if (Type.TANK.equals(type)) {
            return new Tank();
        } else if (Type.TRACTOR.equals(type)) {
            return new Tractor();
        } else if (Type.TRUCK.equals(type)) {
            return new Truck();
        }
        //未知的类型返回null
        return null;

    }


    /**
     * 可以生产的类型
     */
    public enum Type {
        /**
         * 坦克
         */
        TANK,
        /**
         * 拖拉机
         */
        TRACTOR,
        /**
         * 货车
         */
        TRUCK;
    }
}

产品生产者

/**
 * 工厂生产者
 *
 * @author 编程还未
 */
public class FactoryProducer {
    /**
     * 获取子产品的工厂
     *
     * @param type 子产品类型
     * @return 子工厂
     */
    public static AbstractFactory getFactory(AbstractFactory.Type type) {
        if (AbstractFactory.Type.Color.equals(type)) {
            return new ColorFactory();
        }
        if (AbstractFactory.Type.ToolCar.equals(type)) {
            return new ToolCarFactory();
        }
        return null;
    }
}

测试抽象工厂

/**
 * 测试抽象工厂
 *
 * @author 编程还未
 */
public class TestFactory {

    public static void main(String[] args) {


        AbstractFactory colorFactory = FactoryProducer.getFactory(AbstractFactory.Type.Color);
        AbstractFactory toolCarFactory = FactoryProducer.getFactory(AbstractFactory.Type.ToolCar);

        //蓝色
        Color color1 = colorFactory.getColor(ColorFactory.Type.BLUE);
        color1.fill();

        //绿色
        Color color2 = colorFactory.getColor(ColorFactory.Type.GREEN);
        color2.fill();

        //红色
        Color color3 = colorFactory.getColor(ColorFactory.Type.RED);
        color3.fill();

        //现在有情况，需要几辆坦克
        ToolCar toolCar1 = toolCarFactory.getToolCar(ToolCarFactory.Type.TANK);
        toolCar1.run();

        //和平安定，需要拖拉机生产
        ToolCar toolCar2 = toolCarFactory.getToolCar(ToolCarFactory.Type.TRACTOR);
        toolCar2.run();

        //大丰收，需要货车运送货物
        ToolCar toolCar3 = toolCarFactory.getToolCar(ToolCarFactory.Type.TRUCK);
        toolCar3.run();
    }
}

源码下载