重要

UML类图 选自《大话设计模式》

简介

简单工厂模式(Simple Factory Pattern)是一种创建型设计模式,它提供了一种创建对象的方式,将对象的实例化过程封装在一个工厂类中,而客户端代码只需要调用工厂类的方法来获取所需的对象,而无需直接调用构造函数来创建对象。这有助于降低代码的耦合度,使得代码更加灵活和可维护

原理:

以下是简单工厂模式的主要组成部分和工作原理

  • 工厂类(Factory Class):这个类包含一个或多个方法,用于创建不同类型的对象。客户端代码通过调用工厂类的方法来请求对象的创建。工厂类根据传入的参数或条件来决定创建哪种对象。

  • 抽象产品类(Abstract Product Class):这是一个接口或抽象类,定义了产品对象的通用接口,包括产品的属性和方法。

  • 具体产品类(Concrete Product Class):这些类实现了抽象产品类定义的接口或继承了抽象产品类,表示不同类型的具体产品。

工作流程

  • 客户端代码需要创建一个对象,但不直接调用对象的构造函数。

  • 客户端代码调用工厂类的方法,向工厂类传递一个参数或条件,以指示所需的具体产品类型。

  • 工厂类根据传递的参数或条件,选择合适的具体产品类,并调用该类的构造函数来创建对象。

  • 工厂类将创建的对象返回给客户端代码

代码

抽象产品类

/**
 * @author: lpy
 * @Date: 2023/09/13
 * @desc: 抽象操作类
 */
public abstract class Operate {
    /**
     * 抽象操作类的抽象操作方法
     * @param a
     * @param b
     * @return
     */
    public abstract double operate(double a, double b);
}

简单工厂类

/**
 * @author: lpy
 * @Date: 2023/09/13
 * @desc: 简单工厂类
 */
public class OperationFactory {
    /**
     * 注意这里是返回对象!!! 工厂是创建对象的,而不是为了结果
     * @param operator 操作符
     * @return 对象
     */
    public static Operate createOperation(String operator){
        Operate oper = null;
        switch (operator){
            case "+":
                oper = new Add();
                break;
            case "-":
                oper =  new Sub();
                break;
            case "x":
                oper = new Mul();
                break;
            case "/":
                oper =  new Div();
                break;
        }
        return oper;
    }
}

产品类

/**
 * @author: lpy
 * @Date: 2023/09/13
 */
public class Add extends Operate {
    @Override
    public double operate(double a, double b) {
        return a+b;
    }
}
/**
 * @author: lpy
 * @Date: 2023/09/13
 */
public class Div extends Operate {
    @Override
    public double operate(double a, double b) {
        if (0==b){
            throw new RuntimeException("除数不能为0");
        }
        return a/b;
    }
}
/**
 * @author: lpy
 * @Date: 2023/09/13
 */
public class Mul extends Operate {
    @Override
    public double operate(double a, double b) {
        return a*b;
    }
}
/**
 * @author: lpy
 * @Date: 2023/09/13
 */
public class Sub extends Operate {
    @Override
    public double operate(double a, double b) {
        return a-b;
    }
}

代码测试

/**
 * @author: lpy
 * @Date: 2023/09/13
 */
public class SimpleFactoryTest {
    public static void main(String[] args) {
        Operate operation = OperationFactory.createOperation("+");
        double operate = operation.operate(10d, 30d);
        System.out.println(operate);
    }
}

注意

需要注意的是,简单工厂的工厂创建的是对象,要返回的是对象,而不是具象的结果!!!!
就比如你让工厂去给你建造一个车,工厂需要把车造好给你,而不是 给你 车造好了这个信息。

应用

Spring 中的 BeanFactory 就是工厂模式中的简单工厂模式的体现

简单工厂模式优缺点

  • 优点:
    • 只需要传入 正确的参数 , 就可以 获取需要的对象 , 无需知道创建细节 ;
    • 工厂类中有必要的 判断逻辑 , 可以决定 根据当前的参数 创建对应的产品实例 , 客户端可以免除直接创建产品对象的责任 ;
    • 通过该模式 , 实现了对 创建实例 和 使用实例 的 责任分割 ;
    • 提供专门的 工厂类 用于创建对象 , 客户端 无需知道所创建的产品类的类名 , 只需要知道对应产品类的参数即可创建对象实例 ;
  • 缺点:
    • 工厂类 职责 过重 , 如果要增加新的产品 , 需要 修改工厂类的判断逻辑 , 违背 ” 开闭原则 ” ;

7 大设计原则

不能全部遵守 , 也不能不遵守 , 注意平衡 功能 和 系统复杂度 , 找到最合适的一个点 ;

- 单一职责原则(Single Responsibility Principle - SRP):
这个原则规定一个类应该只有一个改变的理由,也就是说,一个类应该只有一个单一的职责。这有助于保持类的简单性和可维护性,因为每个类只需关注一个特定的功能。

- 开放-封闭原则(Open-Closed Principle - OCP):
开放-封闭原则要求系统中的软件实体(类、模块、函数等)应该对扩展开放,对修改封闭。这意味着当需要添加新功能时,应该通过扩展现有代码来实现,而不是修改原有代码。

- 里氏替换原则(Liskov Substitution Principle - LSP):
里氏替换原则规定,子类应该能够替换其父类,而不会影响程序的正确性。也就是说,子类应该继承父类的行为,但可以扩展或修改该行为,但不应该改变父类的行为。

- 接口隔离原则(Interface Segregation Principle - ISP):
接口隔离原则要求一个类不应该强迫其客户端依赖于它们不需要的接口。应该根据客户端的需求定义小而精确的接口,而不是大而笨重的接口。

- 依赖倒置原则(Dependency Inversion Principle - DIP):
依赖倒置原则要求高级模块不应该依赖于低级模块,它们都应该依赖于抽象。具体来说,这意味着应该通过抽象接口或抽象类来定义模块之间的依赖关系,而不是直接依赖于具体实现。

- 迪米特法则(Law of Demeter - LoD):
迪米特法则也被称为最少知识原则,它要求一个对象应该只与其密切的朋友交互,而不应该暴露太多的信息给外部对象。这有助于减少对象之间的耦合度,提高系统的灵活性。

- 合成复用原则(Composite Reuse Principle - CRP):
合成复用原则鼓励通过组合(合成)已有的类来实现新功能,而不是通过继承现有的类。这样可以降低系统的耦合度,并且更加灵活。

源码位置

全部源码github.com/xs-alpha/designPattern

如有内容侵权,麻烦联系博主删除

参考文献

  • 《大话设计模式》

  • csdn


0 条评论

发表评论

Avatar placeholder

您的电子邮箱地址不会被公开。 必填项已用*标注

ICP备案号: 辽ICP备20003309号