23种设计模式之工厂模式

OOP七大原则

• 开闭原则：对拓展开放，对修改关闭
• 里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立
• 依赖倒置原则：要面向接口编程，不要面向实现编程
• 单一职责原则：控制类的粒度大小、将对象解耦，提高内聚性
• 接口隔离原则：要为各个类建立它们需要的专用接口
• 迪米特法则：只与你的直接朋友交谈，不跟“陌生人说话”
• 合成复用原则：尽量先试用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

工厂模式

作用

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

​ 详细分类：简单工厂模式、工厂方法模式、抽象工程模式

满足原则：

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

核心本质：

实例化对象不使用new，用工厂方法替换

将选择实现类，创建对象统一管理和控制。从而将调用者跟实现类解耦

三种模式：

简单工厂模式

​ 用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有代码）

工厂方法模式

​ 用来生产同一等级结构中的固定产品（支持增加任意产品）

抽象工程模式

​ 围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂

生产汽车代码样例

简单工厂模式

汽车接口：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:22
 * @Version 1.0
 */
public interface Car {
    /**
     * 获取名称
     */
    void name();
}

五菱汽车：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:22
 * @Version 1.0
 */
public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

特斯拉汽车：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:23
 * @Version 1.0
 */
public class Tesla implements Car{

    @Override
    public void name() {
        System.out.println("Tesla");
    }
}

简单工厂：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:25
 * @Version 1.0
 */
public class CarFactory {
    public static Car getCar(String car) {
        if ("五菱".equals(car)) {
            return new WuLing();
        }else if ("Tesla".equals(car)) {
            return new Tesla();
        }else {
            return null;
        }
    }
}

消费者：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:24
 * @Version 1.0
 */
public class Consumer {
    public static void main(String[] args) {
        //原始需要创建对象
        Car car = new WuLing();
        Car car1 = new Tesla();
        car.name();
        car1.name();

        Car car2 = CarFactory.getCar("五菱");
        Car car3 = CarFactory.getCar("Tesla");
        assert car2 != null;
        car2.name();
        assert car3 != null;
        car3.name();

    }
}

很明显，简单工厂的弊端，我每新增一个汽车种类都需要修改工厂代码。

工厂方法模式

汽车接口：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:22
 * @Version 1.0
 */
public interface Car {
    /**
     * 获取名称
     */
    void name();
}

五菱汽车：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:22
 * @Version 1.0
 */
public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

特斯拉汽车：

package factory.simple;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:23
 * @Version 1.0
 */
public class Tesla implements Car{

    @Override
    public void name() {
        System.out.println("Tesla");
    }
}

工厂接口：

package factory.method;

import factory.simple.Tesla;
import factory.simple.WuLing;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:25
 * @Version 1.0
 */
public interface CarFactory {
    Car getCar();
}

五菱工厂：

package factory.method;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:42
 * @Version 1.0
 */
public class WulingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

特斯拉工厂：

package factory.method;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:41
 * @Version 1.0
 */
public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

消费者：

package factory.method;

import factory.simple.CarFactory;

/**
 * @Description
 * @Author wangkui
 * @Date 2022-08-22 22:24
 * @Version 1.0
 */
public class Consumer {
    public static void main(String[] args) {
       Car car = new WulingFactory().getCar();
       Car car1 = new TeslaFactory().getCar();

       car.name();
       car1.name();

    }
}

工厂方法可以随意拓展，但是也类也随着增多，代码复杂臃肿。

抽象工程模式

定义：

​ 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

适用场景：

​ 客户端（应用层）不依赖于产品类实例如何被创建，实现等细节

​ 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码

​ 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖具体的实现

优点：

​ 具体产品在应用层的代码隔离，无需关系创建的细节

​ 将一个系列的产品统一到一起创建

缺点：

​ 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难

​ 增加了系统的抽象性和理解难度