java设计模式-创建型模式-抽象工厂模式

抽象工厂模式

当工厂生产的具体产品不只是一个简单对象，而是要生产多组不同类型的产品时，使用工厂方法模式就不适用了。
举例：有一个汽车零件工厂，负责生产一种汽车的零件。零件有发动机、轮子、车身，那么系统中就会有三个工厂类，发动机工厂类，车身工厂类，方向盘工厂类。这时增加了需求，有两家汽车品牌和该工厂开始合作，那么系统中就会增加三个零件类，三个工厂类，这样的话，系统中的类会大量增加，再使用工厂方法模式就不适用了。

四个角色

• 抽象产品角色：因为需要生产多种不同类型的产品，所以会有多个抽象产品
• 具体产品角色：抽象产品的子类
• 抽象工厂角色：定义一组产出不同产品的方法
• 具体工厂角色：抽象工厂的子类

例子

汽车工厂（假如汽车的所有零件都是有自己的工厂生产），假设汽车就需要发动机、车身、轮子、方向盘。
有两条生产线，奔驰汽车生产线和宝马汽车生产线，用抽象工厂模式来模拟

• 定义抽象产品角色（4个）

/**
 * 车身抽象类
 */
public interface CarBody {
    void body();
}

/**
 * 发动机抽象类
 */
public interface CarEngine {
    void engine();
}

/**
 * 轮子抽象类
 */
public interface CarWheel {
    void wheel();
}

/**
 * 方向盘抽象类
 */
public interface CarSteer {
    void steer();
}

• 定义具体产品角色（2组8个）

public class BenzCarBody implements CarBody {
    @Override
    public void body() {
        System.out.println("奔驰车身");
    }
}

public class BenzCarEngine implements CarEngine {
    @Override
    public void engine() {
        System.out.println("奔驰发动机");
    }
}

public class BenzCarWheel implements CarWheel {
    @Override
    public void wheel() {
        System.out.println("奔驰轮子");
    }
}

public class BenzCarSteer implements CarSteer {
    @Override
    public void steer() {
        System.out.println("奔驰方向盘");
    }
}

宝马四个实现类省略。。。

• 定义抽象工厂类（产出四种产品）

public interface CarFactory {

    CarBody createCarBody();

    CarEngine createCarEngine();

    CarWheel createCarWheel();
    
    CarSteer createCarSteer();
}

• 组合一个简单的模板方法模式，定义一个生产汽车的流程

public abstract class ProductionFlow implements CarFactory {
    public final void createCar() {
        createCarBody().body();
        createCarEngine().engine();
        createCarWheel().wheel();
        createCarSteer().steer();
    }
}

• 定义奔驰、宝马两个具体工厂

public class BenzCarFactory extends ProductionFlow {

    @Override
    public CarBody createCarBody() {
        return new BenzCarBody();
    }

    @Override
    public CarEngine createCarEngine() {
        return new BenzCarEngine();
    }

    @Override
    public CarWheel createCarWheel() {
        return new BenzCarWheel();
    }

    @Override
    public CarSteer createCarSteer() {
        return new BenzCarSteer();
    }
}

public class BMWCarFactory extends ProductionFlow {
    @Override
    public CarBody createCarBody() {
        return new BMWCarBody();
    }

    @Override
    public CarEngine createCarEngine() {
        return new BMWCarEngine();
    }

    @Override
    public CarWheel createCarWheel() {
        return new BMWCarWheel();
    }

    @Override
    public CarSteer createCarSteer() {
        return new BMWCarSteer();
    }
}

• 编写测试例子

public class Main {
    public static void main(String[] args) {
        System.out.println("生产一辆宝马车");
        BMWCarFactory bmwCarFactory = new BMWCarFactory();
        bmwCarFactory.createCar();
        System.out.println("-------------------");
        System.out.println("生产一辆奔驰车");
        BenzCarFactory benzCarFactory = new BenzCarFactory();
        benzCarFactory.createCar();
    }
}

• 结果

生产一辆宝马车
宝马车身
宝马发动机
宝马轮子
宝马方向盘
-------------------
生产一辆奔驰车
奔驰车身
奔驰发动机
奔驰轮子
奔驰方向盘

总结

优点：工厂模式隔离了类的生成，增加一组对象的生产更加容易，并且在新增一族对象时，无需修改现有代码，符合开闭原则
缺点：缺点也很明显，如果需要增加一种新的对象的生成，需要修改抽象工厂类、具体工厂类，违背了开闭原则。扩展容易修改不易。

回到主目录