抽象工厂模式

使命

抽象工厂模式（Abstract Factory Pattern）的出现也是为了解决接口选择问题，它不同于工厂模式的是抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

继工厂模式之后能生产不同车辆的工厂升级了，它的能力增强了，它能造飞机了，那么我们是如何让原有的工厂升级为超级工厂的呢？

客户调用是先选择工厂再生产出目标产物
public class Client {

    public static void main(String[] args) {
        FactoryProductor productor = new FactoryProductor();

        //获取汽车工厂
        AbstractFactory vehicleFactory = productor.getFactory("VEHICLE");

        //生产宝马
        IVehicle bmw = vehicleFactory.productVehicle("BMW");
        bmw.whistle();
        bmw.drive();
        System.out.println("-----------------------------------");

        //获取飞机工厂
        AbstractFactory  planeFactory = productor.getFactory("PLANE");

        //生产波音747
        IPlane boyin747 = planeFactory.productPlane("BOYIN");
        boyin747.whistle();
        boyin747.fly();

    }

}

超级工厂，生产工厂的工厂

public class FactoryProductor {

    public AbstractFactory getFactory(String name) {
        AbstractFactory factory = null;
        if ("PLANE".equals(name)) {
            factory = new PlaneFactory();
        } else if ("VEHICLE".equals(name)) {
            factory = new VehicleFactory();
        }
        return factory;
    }
}

工厂父类

public abstract class AbstractFactory {

    /**
     * 生产汽车
     *
     * @return
     */
    public abstract IVehicle productVehicle(String name);

    /**
     * 生产飞机
     *
     * @param name
     * @return
     */
    public abstract IPlane productPlane(String name);
}

汽车工厂

public class VehicleFactory extends AbstractFactory {

    @Override
    public IVehicle productVehicle(String name) {
        IVehicle vehicle = null;
        if ("BENZ".equals(name)){
            vehicle = new Benz();
        }else if("BMW".equals(name)){
            vehicle = new BMW();
        }else if ("AUDI".equals(name)){
            vehicle = new Audi();
        }
        return vehicle;
    }

    @Override
    public IPlane productPlane(String name) {
        return null;
    }
}

汽车接口

public interface IVehicle {

    /**
     * 鸣笛
     */
    void whistle();

    /**
     * 行驶
     */
    void drive();
}

宝马

public class BMW implements IVehicle {

    @Override
    public void whistle() {
        System.out.println("宝马在鸣笛......");
    }

    @Override
    public void drive() {
        System.out.println("宝马在行驶......");
    }
}

飞机工厂

public class PlaneFactory extends AbstractFactory {

    @Override
    public IVehicle productVehicle(String name) {
        return null;
    }

    @Override
    public IPlane productPlane(String name) {
        IPlane plane = null;
        if ("BOYIN".equals(name)){
            plane = new Boyin();
        }else if("JIAN20".equals(name)){
            plane = new Jian20();
        }
        return plane;
    }
}

飞机接口

public interface IPlane {
    /**
     * 鸣笛
     */
    void whistle();

    /**
     * 行驶
     */
    void fly();
}

波音747

public class Boyin implements IPlane {

    @Override
    public void whistle() {
        System.out.println("波音747在鸣笛......");
    }

    @Override
    public void fly() {
        System.out.println("波音747在飞行......");
    }
}