大话设计模式——7.抽象工厂模式（Abstract Factory Pattern）

1.介绍

抽象工厂模式是工厂模式的进一步优化，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。属于创建型模式。
UML图：

2.示例

车辆制造工厂，不仅可以制造轿车也可以用来生产自行车。
1）AbstractFactory：VehicleFactory

public interface VehicleFactory {

    /**
     * 建造自行车
     *
     * @return
     */
    Bike createBike();

    /**
     * 建造轿车
     *
     * @return
     */
    Car createCar();
}

2）AbstractProductA：Bike

public interface Bike {

    void bikeName();
}

3）AbstractProductB：Car

public interface Car {

    void carName();
}

4）ConcreteFactoryA：BMWVehicleFactory

public class BMWVehicleFactory implements VehicleFactory {

    @Override
    public Bike createBike() {
        return new BMWBike();
    }

    @Override
    public Car createCar() {
        return new BMWCar();
    }
}

5）ConcreteFactoryB：TeslaVehicleFactory

public class TeslaVehicleFactory implements VehicleFactory {

    @Override
    public Bike createBike() {
        return new TeslaBike();
    }

    @Override
    public Car createCar() {
        return new TeslaCar();
    }
}

6）ConcreteProductA1：BMWCar

public class BMWCar implements Car{

    @Override
    public void carName() {
        System.out.println("宝马 x5 四驱 燃油车");
    }
}

7）ConcreteProductA2：TeslaCar

public class TeslaCar implements Car {

    @Override
    public void carName() {
        System.out.println("特斯拉 modelY 四驱 电动车");
    }
}

8）ConcreteProductB1：BMWBike

public class BMWBike implements Bike{

    @Override
    public void bikeName() {
        System.out.println("宝马 碳纤维 大喇叭 二驱 自行车");
    }
}

9）ConcreteProductB2：TeslaCar

public class TeslaCar implements Car {

    @Override
    public void carName() {
        System.out.println("特斯拉 modelY 四驱 电动车");
    }
}

10）运行：
结合建议工厂模式：工厂生产者，可以再进行优化，通过反射的机制动态构建

public class VehicleFactoryProducer {


    /**
     * 超级工厂
     *
     * @param vehicleName
     * @return
     */
    public static VehicleFactory creatVehicleFactory(String vehicleName) {
        if ("BMW".equals(vehicleName)) {
            return new BMWVehicleFactory();
        } else if ("Tesla".equals(vehicleName)) {
            return new TeslaVehicleFactory();
        }

        return null;
    }
}

运行类

public class Main {

    public static void main(String[] args) {

        System.out.println("------BMW制造工厂-----");
        VehicleFactory bmwFactory = VehicleFactoryProducer.creatVehicleFactory("BMW");
        bmwFactory.createBike().bikeName();
        bmwFactory.createCar().carName();

        System.out.println("\n------Tesla制造工厂-----");
        VehicleFactory teslaFactory = VehicleFactoryProducer.creatVehicleFactory("Tesla");
        teslaFactory.createCar().carName();
        teslaFactory.createBike().bikeName();
    }
}

3.总结

1）优点：
a. 让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂实现分离，不会出现在客户代码中
b. 可以保证使用方始终只使用同一个产品族中的对象
c. 扩展容易，只需要增加新的产品类和对应的工厂类即可

2）缺点：
a. 不符合开闭原则，新增产品类时需要修改抽象工厂和抽象产品中的代码
b. 增加了系统的复杂性和抽象性