Java设计模式之工厂模式(简单工厂模式+工厂方法模式+抽象工厂模式)

 

最近正好有时间回顾了下工厂模式，一般包含有如下三种工厂模式：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

1、简单工厂模式：

1.1、模式定义：

简单工厂模式又称为静态工程方法模式，它属于类创建模式。在简单工厂中，专门定义一个工厂类用来创建其他类的实例，并且可以根据不同的参数来获取不同的类实例。

简单工厂模式并不算是一种设计模式，不在23种模式之列，简单工程更多的是一种编程习惯。

1.2、适用场景：

• 需要创建的对象较少。
• 客户端不关心对象的创建过程。

1.3、模式结构：

简单工厂模式包含如下角色：

• 工厂角色
• 抽象产品角色
• 具体产品角色

简单工程类图如下所示：

1.4、模式实例：

抽象产品类---Car：

public interface Car {
    /**
     * 驾驶
     */
    void drive();
}

 

具体产品类1---BMWCarX5：

public class BMWCarX5 implements Car {
    @Override
    public void drive() {
        System.out.println("宝马X5--启动啦！！！");
    }
}

具体产品类2---BMWCarX7：

public class BMWCarX7 implements Car {
    @Override
    public void drive() {
        System.out.println("宝马X7--启动啦！！！");
    }
}

工厂类---CarFactory:

public class CarFactory {
    public static Car createCar(int carType) {
        Car car = null;
        switch (carType) {
            case CarTypeDef.CAR_TYPE_BMW_X5:
                //宝马X5系列
                car = new BMWCarX5();
                break;
            case CarTypeDef.CAR_TYPE_BMW_X7:
                //宝马X7系列
                car = new BMWCarX7();
                break;
            default:
                break;
        }
        return car;
    }
}

测试及输出结果：

public static void main(String[] args) {
        /**
         * 测试简单工厂
         */
        Car carBMW = CarFactory.createCar(CarTypeDef.CAR_TYPE_BMW_X5);
        carBMW.drive();

        Car carBenz = CarFactory.createCar(CarTypeDef.CAR_TYPE_BMW_X7);
        carBenz.drive();
    }

如上即是简单工厂模式的实际应用，可以看出简单工厂模式通过一个具体的工厂类，根据不同的产品参数创建不同的具体产品实例。客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品。这种模式用于创建同一类型的产品来说，还是比较方便和灵活的。但是这种方式也有其缺点，比如每一次创建一个新的产品，就需要修改工厂类，违背了"开闭原则"(对扩展开放，对修改关闭)。并且在创建其他非Car产品时就显得无能为力了。

 

 

2、工厂方法模式：

2.1、模式定义：

工厂方法模式又称为工厂模式，或者多态工厂模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象。这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

2.2、适用场景：

• 客户端不需要知道它所创建的对象的类。
• 客户端可以通过子类来指定创建对应的对象。

2.3、模式结构：

工厂模式包含如下角色：

• 抽象产品角色
• 具体产品角色
• 抽象工厂角色
• 具体工厂角色

 

2.4、模式实例：

抽象产品类---Car：

public interface Car {
    /**
     * 驾驶
     */
    void drive();
}

 

具体产品类1---BMWCar:

public class BMWCar implements Car {

    public BMWCar(){
        System.out.println("BMWCar--生产啦");
    }

    @Override
    public void drive() {
        System.out.println("BMWCar--启动啦");
    }
}

具体产品类2---BenzCar:

public class BenzCar implements Car {
    
    public BenzCar() {
        System.out.println("BenzCar--生产啦");
    }

    @Override
    public void drive() {
        System.out.println("BenzCar--启动啦");
    }
}

抽象工厂类---ICarFactory：

public interface ICarFactory {
    Car createCar();
}

具体工厂类1---BMWCarFactory

public class BMWCarFactory implements ICarFactory {
    @Override
    public BMWCar createCar() {
        System.out.println("begin--create--BMWCar");
        return new BMWCar();
    }
}

具体工厂类2---BenzCarFactory

public class BenzCarFactory implements ICarFactory {
    @Override
    public BenzCar createCar() {
        System.out.println("begin--create--BenzCar");
        return new BenzCar();
    }
}

测试及输出结果：

public static void main(String[] args) {
        /**
         * 测试工厂模式
         */
        BMWCarFactory bmwCarFactory = new BMWCarFactory();
        bmwCarFactory.createCar().drive();

        BenzCarFactory benzCarFactory = new BenzCarFactory();
        benzCarFactory.createCar().drive();

    }

如上即是工厂方法模式的实例，可以看到工厂方法模式对于简单工厂模式来说并没有违背“开闭原则”（对修改关闭，对扩展开放）。另外，工厂方法模式中的具体工厂也可以通过反射来生产不同厂家的产品，这样具体的工厂实例只创建一个就可以了。

而当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时工厂方法的弊端就显露出来了，此时便需要使用抽象工厂模式。

 

 

3、抽象工厂模式：

3.1、模式定义：

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式属于对象创建型模式。抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不单单可以创建一个对象，而是可以创建一组对象，这是和工厂方法最大的不同点。

3.2、适用场景：

• 和工厂方法一样客户端不需要知道它所创建的对象的类。
• 需要一组对象共同完成某种功能时。并且可能存在多组对象完成不同功能的情况。
• 系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）。

3.3、模式结构：

抽象工厂模式包含如下角色：

• 抽象产品角色
• 具体产品角色
• 抽象工厂角色
• 具体工厂角色

抽象工程类图如下：

3.4、模式实例：

抽象产品类A---Engine：

public interface Engine {
    /**
     * 发动机转动
     */
    void rotate();
}

具体产品类A1---BMWEngine:

public class BMWEngine implements Engine {

    public BMWEngine(){
        System.out.println("BMWEngine--生产啦");
    }

    @Override
    public void rotate() {
        System.out.println("BMWEngine--rotate");
    }
}

具体产品类A2---BenzEngine:

public class BenzEngine implements Engine {

    public BenzEngine(){
        System.out.println("BenzEngine--生成啦");
    }

    @Override
    public void rotate() {
        System.out.println("BenzEngine--rotate");
    }
}

 

抽象产品类B---AirConditioner：

public interface AirConditioner {
    /**
     * 空调吹风
     */
    void blow();
}

具体产品类B1---BMWAirConditioner:

public class BMWAirConditioner implements AirConditioner {

    public BMWAirConditioner(){
        System.out.println("BMWAirConditioner--生产啦");
    }

    @Override
    public void blow() {
        System.out.println("BMWAirConditioner--blow");
    }
}

具体产品类B2---BenzAirConditioner:

public class BenzAirConditioner implements AirConditioner {

    public BenzAirConditioner() {
        System.out.println("BenzAirConditioner--生产啦");
    }

    @Override
    public void blow() {
        System.out.println("BenzAirConditioner--blow");
    }
}

抽象工厂类---ICarFactory：

public interface ICarFactory {
    /**
     * 制造发动机
     * @return
     */
    Engine createEngine();

    /**
     * 制造空调
     * @return
     */
    AirConditioner createAirConditioner();
}

具体工厂类---BMWCarFactory：

public class BMWCarFactory implements ICarFactory {

    @Override
    public Engine createEngine() {
        return new BMWEngine();
    }

    @Override
    public AirConditioner createAirConditioner() {
        return new BMWAirConditioner();
    }
}

具体工厂类---BenzCarFactory：

public class BenzCarFactory implements ICarFactory {

    @Override
    public Engine createEngine() {
        return new BenzEngine();
    }

    @Override
    public AirConditioner createAirConditioner() {
        return new BenzAirConditioner();
    }
}

测试及输出结果：

public static void main(String[] args) {

        /**
         * 测试抽象工厂模式
         */
        ICarFactory bmwCarFactory = new BMWCarFactory();
        bmwCarFactory.createEngine().rotate();
        bmwCarFactory.createAirConditioner().blow();

        ICarFactory benzCarFactory = new BenzCarFactory();
        benzCarFactory.createEngine().rotate();
        benzCarFactory.createAirConditioner().blow();

    }

 

最后根据工厂模式的退化说明，来对这三种工厂模式做一个简单精辟的总结：

当抽象工厂模式中每一个具体的工程类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中，抽象工程与具体工厂合并，提供一个统一的工厂对象来创建产品，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。

 

查看其它Java设计模式

 

参考：

工厂模式——看这一篇就够了

创建型模式

JAVA设计模式之工厂模式(简单工厂模式+工厂方法模式)