大话设计模式——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. 增加了系统的复杂性和抽象性