抽象工厂模式

抽象工厂模式

简介

通过一个抽象的工厂类，来管理创建多个工厂。

很多情况下，一个工厂很难满足产品的需求。比如一台电脑的构成，需要主机，显示器，外设组成，这就需要多个工厂来提供部件最后来进行组装完成产品。在这种情况下，单一的工厂模式就很难提供支持了。所以我们需要使用抽象工厂模式，用一个抽象工厂来管理，为用户提供多个不同的工厂去创建部件最后组合成实体。

抽象工厂模式可以清晰的体现，面向对象设计的 “针对修改关闭，对扩展开放”思想。

通过抽象工厂模式，客户端不用再关心对象是如何创建的，对象创建的具体细节是什么，只需要提供需求，其他的交给工厂来实现。

模型图

代码实现

Parking接口

public interface Parking {

    void cast();

}

Transportation接口

public interface Transportation {

    void cast();

}

ParkingFactory 停放场地工厂

这里省略了建立实体类的过程节约时间，直接使用了匿名内部类

public class ParkingFactory extends AbsFactory {

    private Parking parking;

    @Override
    public Transportation buyTransportation(String transportationType) throws Exception {
        return null;
    }

    @Override
    public Parking buyParking(String parkingType) throws Exception {
        if (parkingType != null){
            switch (parkingType){
                case "Circle":
                    parking = ()->{
                        System.out.println("自行车放家里不要钱");
                    };
                    break;
                case "Car":
                    parking = ()->{
                        System.out.println("地下停车场800一月");
                    };
                    break;
                case "Plane":
                    parking = ()->{
                        System.out.println("停机坪买不起");
                    };
                    break;
                default:
                    throw new Exception("不提供此类型停放区域");
            }
            return parking;
        }
        return null;
    }
}

TransportationFactory 交通工具工厂

这里省略了建立实体类的过程节约时间，直接使用了匿名内部类

public class TransportationFactory extends AbsFactory{

    private Transportation transportation;

    @Override
    public Transportation buyTransportation(String type) throws Exception {
        if (type!=null) {
            switch(type){
                case "Circle":
                    transportation = ()->{
                        System.out.println("自行车价值1w");
                    };
                    break;
                case "Car":
                    transportation = ()->{
                        System.out.println("汽车价值10w");
                    };
                    break;
                case "Plane":
                    transportation = ()->{
                        System.out.println("买不起");
                    };
                    break;
                default:
                    throw new Exception("不提供此类型交通工具");
            }
        }
        return transportation;
    }

    @Override
    public Parking buyParking(String parkingType) {
        return null;
    }

}

FactoryProvider 提供工厂类

public class FactoryProvider {
    public static AbsFactory getFactory(String type){
        if (type != null) {
            switch (type){
                case "TransFactory":
                    return new TransportationFactory();
                case "ParkFactory":
                    return new ParkingFactory();
            }
        }
        return null;
    }
}

Client 客户端

public class Client {

    private static final String CIRCLE = "Circle";
    private static final String CAR = "Car";
    private static final String PLANE = "Plane";

    public static void main(String[] args) {
        AbsFactory transportationFactory = FactoryProvider.getFactory("TransFactory");
        AbsFactory parkingFactory = FactoryProvider.getFactory("ParkFactory");
        try {
            transportationFactory.buyTransportation(CIRCLE).cast();
            transportationFactory.buyTransportation(CAR).cast();
            transportationFactory.buyTransportation(PLANE).cast();
            parkingFactory.buyParking(CIRCLE).cast();
            parkingFactory.buyParking(CAR).cast();
            parkingFactory.buyParking(PLANE).cast();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果