设计模式-抽象工厂模式

抽象工厂模式

引言

生产一辆汽车，既要有车壳还要有车轮，而车壳和车轮可能是不同的厂家生产的。

正文

抽象工厂模式是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就可以得到同族的不同等级的产品的模式结构。

代码实现

一辆小车需要车壳和车轮组成，车轮可以由吉利和米其林提供，车壳可以由奥迪和宝马提供。

//车壳接口
public interface BodyBrand {
    void produceCarBody();
}

//奥迪车壳
public class AudiCarBody implements BodyBrand {

    private String name;

    public AudiCarBody(String name) {
        this.name = name;
    }

    @Override
    public void produceCarBody() {
        System.out.println("制造了" + name + "车壳");
    }
}

//宝马车壳
public class BMWCarBody implements BodyBrand {

    private String name;

    public BMWCarBody(String name) {
        this.name = name;
    }

    @Override
    public void produceCarBody() {
        System.out.println("制造了" + name + "车壳");
    }
}

//车壳的简单工厂类
public class CarBodyFactory {

    public static BodyBrand produceCarBody(int type) {
        BodyBrand bodyBrand = null;
        switch (type) {
            case 1:
                bodyBrand = new AudiCarBody("奥迪");
                break;
            case 2:
                bodyBrand = new BMWCarBody("宝马");
                break;
        }
        return bodyBrand;
    }
}

//车轮接口
public interface WheelBrand {
    void produceWheel();
}

//吉利车轮
public class GeliWheelBrand implements WheelBrand {

    private String name;

    public GeliWheelBrand(String name) {
        this.name = name;
    }

    @Override
    public void produceWheel() {
        System.out.println("制造了" + name + "轮胎");
    }
}

//米其林车轮
public class MichelinWheelBrand implements WheelBrand {

    private String name;

    public MichelinWheelBrand(String name) {
        this.name = name;
    }

    @Override
    public void produceWheel() {
        System.out.println("制造了" + name + "轮胎");
    }
}

//车轮简单工厂
public class CarWheelFactory {

    public static WheelBrand produceCarWheel(int type) {
        WheelBrand wheelBrand = null;
        switch (type) {
            case 1:
                wheelBrand = new GeliWheelBrand("吉利");
                break;
            case 2:
                wheelBrand = new MichelinWheelBrand("米其林");
                break;
        }
        return wheelBrand;
    }
}

//小车工厂类
public class CarFactory {

    private BodyBrand bodyBrand = null;
    private WheelBrand wheelBrand = null;

    public void produceCar(int bodyType, int wheelType) {
        System.out.println("准备开始造车了");
        prepareCarComponents(bodyType, wheelType);
        System.out.println("一辆车制造好了");
    }

    private void prepareCarComponents(int bodyType, int wheelType) {
        this.bodyBrand = CarBodyFactory.produceCarBody(bodyType);
        this.wheelBrand = CarWheelFactory.produceCarWheel(wheelType);
        this.bodyBrand.produceCarBody();
        this.wheelBrand.produceWheel();
    }
}

//调用
public class Main {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.produceCar(1, 1);
    }
}

输出结果

准备开始造车了
制造了奥迪车壳
制造了吉利轮胎
一辆车制造好了

总结

抽象工厂模式实质上时工厂方法模式的一种升级，相比工厂方法模式，它可以针对同一产品制造出不同的组合的同类产品。它适用于创建一系列相互依赖的产品族，比如汽车、家电等。当然，如果只有一个产品族时，抽象工厂模式将自动回退到工厂方法模式。