23种设计模式（2）-工厂模式

定义

工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

介绍

作用：实现了创建者和调用者的分离

满足的OOP七大原则：

• 开闭原则
• 依赖倒置原则
• 迪米特法则

核心本质：

• 实例化对象不使用new，用工厂方法代替
• 将选择实现类，创建对象统一管理和控制。从而将调用者和我们的实现类解耦

注意：

• 对于复杂类，推荐使用工厂模式
• 对于简单类，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式（如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度）

详细分类

简单工厂模式（静态工厂模式）

一句话介绍：①增加一个中间工厂类，用于创建产品对象 ②方法是静态的

不推荐使用

• 之所以静态工厂模式，是因为工厂的方法是静态的方法
• 对于新增的产品，需要去覆盖已经存在的代码
• 用来生产同一等级结构中的任意产品

//汽车接口
interface Car {
    void printName();
}
//小汽车实现汽车接口
class smallCar implements Car {
    @Override
    public void printName() {
        System.out.println("smallCar");
    }
}
//大汽车实现汽车接口
class largeCar implements Car {
    @Override
    public void printName() {
        System.out.println("largeCar");
    }
}
//静态工厂
public class CarFactory {
    //方式一：根据传入的参数决定汽车的类型
    public static Car getCar(String car) {
        switch (car) {
            case "smallCar":
                return new smallCar();
            case "largeCar":
                return new largeCar();
            default:
                return null;
        }
    }
    //方式二：根据调用的方法决定汽车的类型
    public static Car getSmallCar(){
        return new smallCar();
    }
    public static Car getLargeCar(){
        return new largeCar();
    }
}
//测试类（消费者、调用者）
class consumer {
    public static void main(String[] args) {
        CarFactory.getCar("smallCar").printName();
        CarFactory.getSmallCar().printName();
        CarFactory.getLargeCar().printName();
    }
}

上面的是静态工厂的写法，根据调用者传入给静态工厂的参数（或者根据调用的方法），从而决定创建的是何种汽车类型

虽然看起来简单，但是有缺点

• 不满足开闭原则（维护复杂）

工厂方法模式

一句话介绍：①增加一个中间工厂接口 ②每增加一种产品，就要增加一个对应工厂类实现工厂接口 ③创建产品工作交给工厂完成

• 用来生产同一等级结构中的任意产品

//汽车接口
interface Car{
    void printName();
}
//小汽车
class SmallCar implements Car{
    @Override
    public void printName() {
        System.out.println("smallCar");
    }
}
//大汽车
class LargeCar implements  Car{
    @Override
    public void printName() {
        System.out.println("largeCar");
    }
}

//工厂接口
public interface CarFactory {
    Car getCar();
}
//创建SmallCar的工厂
class SmallCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new SmallCar();
    }
}
//创建LargeCar的工厂
class LargeCarFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new LargeCar();
    }
}

//测试类（消费者、调用者）
class Consumer {
    public static void main(String[] args) {
        //用小汽车工厂生产小汽车
        System.out.println(new SmallCarFactory().getCar());
        //用大汽车工厂生产大汽车
        System.out.println(new LargeCarFactory().getCar());
    }
}

优点：

1. 一个调用者想创建一个对象，只要知道其名称就可以了
2. 扩展性高（因为满足开闭原则），如果想要增加一个产品，只要扩展一个工厂类就可以
3. 屏蔽产品的具体实现，调用者只关心产品的接口

缺点：

1. 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这不是什么好事。

抽象工厂模式

也是一种创建型模式

一句话介绍：围绕一个超级工厂创建其他工厂。该超级工厂又称为工厂的工厂。

具体介绍转战到另一篇博客：23种设计模式（5）-抽象工厂模式