✨作者：猫十二懿

❤️‍🔥账号：CSDN 、掘金、个人博客、Github

🎉公众号：猫十二懿

这里只是简单的将《大话设计模式【Java溢彩加强版】》的内容简单是复述一下，并加上自己的理解

简单工厂模式

1、引入问题

首先我们看看用Java实现一个简单是计算器程序：

/**
 * @author Shier
 * CreateTime 2023/4/7 16:22
 * 简单的计算器
 */
public class SimpleCalculate {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数字A:");
        String A = scanner.nextLine();
        System.out.print("请选择进行的操作运行（/、*、-、+）:");
        String B = scanner.nextLine();
        System.out.print("请输入数字B:");
        String C = scanner.nextLine();
        double D = 0d;
        if (B.equals("+")) {
            D = Double.parseDouble(A) + Double.parseDouble(C);
        }
        if (B.equals("-")) {
            D = Double.parseDouble(A) - Double.parseDouble(C);
        }
        if (B.equals("*")) {
            D = Double.parseDouble(A) * Double.parseDouble(C);
        }
        if (B.equals("/")) {
            D = Double.parseDouble(A) / Double.parseDouble(C);
        }
        System.out.println("计算结果:" + D);
    }
}

从上面的程序你看出了什么问题了吗？

存在的问题：

变量名定义不规范（以上程序中使用A、B、C）
判断分支，进行一次运行，就全部都要去执行，耗时过长，比如做加法，其他的减乘除的判断都要去执行一次，做了三次的无用功。
除数为0，没有做容错的判断
大量的使用Double.parseDouble()类型解析

下面我们来改进一下代码：

public class SimpleCalculate {
    public static void main(String[] args) {
        // 代码规范之后
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入数字A:");
            Double numberA = Double.parseDouble(scanner.nextLine());
            System.out.print("请选择进行的操作运行（/、*、-、+）:");
            String strOperate = scanner.nextLine();
            System.out.print("请输入数字B:");
            Double numberB = Double.parseDouble(scanner.nextLine());
            double result =0d;
            switch (strOperate){
                case "+":
                    result =numberA+numberB;
                    break;
                case "/":
                    result=numberA/numberB;
                    break;
                case "-":
                    result=numberA-numberB;
                    break;
                case "*":
                    result=numberA*numberB;
                    break;
                default:
                    break;
            }
            System.out.println("计算结果:" + result);
        }catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
}

改进之后看起来舒服多了。但是这样就是最好了的吗？

思考：上面的程序，怎样能做到容易维护，容易扩展，又容易复用呢？

2、面向对象编程

一般好的程序都要做到以下四点：

可维护：修改要修改之处，不需全部改动
可扩展：有新的功能，只要添加新的功能即可，又不会破坏原来的功能
可复用：可以多次使用相同的程序
灵活性好

面向对象的好处：通过封装、继承、多态降低程序的耦合度

不要把所有的功能都写在一起，这样子就会高耦合，难以维护。

所有我们就要将上面的计算器程序中的业务逻辑和界面逻辑分开。也就是计算和控制台显示的内容进行拆分。

怎么进行拆分？

这时候就需要进行业务逻辑的封装，封装成一个方法，在使用到计算的地方，进行调用这个方法即可

3、业务封装

下面就对上面的计算器程序进行封装

测试类中当中修改如下：

// 代码规范之后
try {
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入数字A:");
    Double numberA = Double.parseDouble(scanner.nextLine());
    System.out.print("请选择进行的操作运行（/、*、-、+）:");
    String strOperate = scanner.nextLine();
    System.out.print("请输入数字B:");
    Double numberB = Double.parseDouble(scanner.nextLine());
    double result = Operate.getResult(numberA, numberB, strOperate);
    System.out.println("计算结果:" + result);
} catch (Exception e) {
    System.out.println(e.getMessage());
}

Operate 就是单独的计算类。

如果其他的程序都想使用计算这个功能，只要在调用这个类下的getResult方法，传入对应的参数即可，这样封装的好处就体现出来了。

在其他程序当中都能轻松的使用同样代码，就不是CV工程师了（CV带给我们的只会是劳累的工作），CV会变得高耦合，而如下这样的程序就会降低耦合。

体现可维护、可扩展、可复用的特点。

/**
 * @author Shier
 * CreateTime 2023/4/7 17:21
 */
public class Operate {
    public static double getResult(double numberA, double numberB, String operate) {
        double result = 0d;
        switch (operate) {
            case "+":
                result = numberA + numberB;
                break;
            case "/":
                result = numberA / numberB;
                break;
            case "-":
                result = numberA - numberB;
                break;
            case "*":
                result = numberA * numberB;
                break;
            default:
                break;
        }
        return result;
    }

}

4、紧耦合VS松耦合

在上面的程序中还是存在着一些问题的。比如现在我要增加多一个求平方的功能，虽说是只要在switch 中添加一个case 即可，但是这样会带来紧耦合的作用。也就是说，我只要求算平方这个运算，但是其他的加减乘除都过来一起编译，这样的可能存在影响。（可能有意或无意修改了一些代码，带来的后果是非常大的）

紧耦合：各个模块之间的依赖程度很高，一旦某个模块发生变化会影响到其他模块的运行，导致整个系统变得难以维护和扩展。这种情况下，代码之间的联系比较紧密，如同钢琴里的琴弦一样紧绷。

松耦合：各个模块之间的依赖程度较低，模块之间的关系十分灵活，一个模块的变化不会对其他模块造成太大的影响。这种情况下，代码之间的联系相对较松，如同各自独立演奏的乐器一样。

所以说我们可以使用基础，抽象出一个运算的抽象类，有一个运算结果的方法，然后让每个不同的运算类来继承这个抽象类，从而得到松耦合的作用，更加的灵活。

运算抽象类：

/**
 * @author Shier
 * CreateTime 2023/4/7 17:21
 */
public abstract class Operate {
    public double getResult(double numberA, double numberB) {
        return 0d;
    }
}

加减乘除类：

在这里插入图片描述

5、简单工厂模式

但是根据上面的修改程序之后，我该怎么样去实例化对象呢？下面就来看看这个简单工厂模式

为了防止以后的需求增加（再增加一个指数运算的功能），我们最好就是单独一个类来作为实例化的对象，这样就相当于一个工厂。

简单工厂模式是一种常用的创建型设计模式，其主要目的是通过一个工厂类来创建不同类对象的实例，而无需直接使用 new 操作符来创建对象。

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

抽象产品类：定义了工厂创建的产品对象的公共接口。（也就是上面的运算抽象类）
具体产品类：实现了抽象产品类接口的具体产品，是工厂方法创建的对象。（也就是通过继承抽象类的加减乘除类）
工厂类：负责创建具体产品的对象，通常包含一个创建产品对象的公共静态方法。（也就是下面的工厂运算类）

在简单工厂模式中，客户端通过调用工厂类的静态方法来获取所需的具体产品对象。工厂类根据客户端传递的参数不同，动态创建不同的具体产品对象，并返回给客户端使用。

与直接使用 new 关键字相比，简单工厂模式使得客户端代码更加灵活，能够随着需求的变化而动态修改创建对象的行为。

简单运算工厂类：

/**
 * @author Shier
 * CreateTime 2023/4/8 17:56
 */
public class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new Add();
                break;
            case "/":
                operation = new Div();
                break;
            case "-":
                operation = new Sub();
                break;
            case "*":
                operation = new Mul();
                break;
            default:
                break;
        }
        return operation;
    }
}

只需要输入运算符号，工厂就实例化出合适的对象，通过多态，返回父类的方式实现了计算器的结果

客户端调用：

最后的结构图如下

程序的执行过程如下介绍：

进入主函数（main），输入numberA，numberB，已经运算符号（这里我选择用加法）
然后就到简单工厂类进行判断运算符是哪一个运算，这里是加法则进行new Add() 创建这个对象
然后就进入Add类，继承了Operation类，也要进去Operation类，但是还没有进行调用，此时case + 退出
通过调用getResult方法，在Add类进行计算，最终将返回结果。

6、UML类图

UML（Unified Modeling Language）图是一种用于软件系统设计和开发的标准化建模语言，是用于构建和可视化面向对象系统的图形表示法。它可以帮助我们更好地理解系统和软件的结构、行为、交互及其功能。UML图通常被用来描述软件的静态结构（如类、对象、接口等）或者动态行为（如用例、时序图等）。UML图包括用例图、类图、时序图、活动图、组件图、部署图等多种类型，可以根据需求选择使用其中的一种或多种类型进行建模。它是一种静态结构图，在统一建模语言（UML）中被用来描述系统的结构，包括类、它们的属性、操作（或方法）以及对象之间的关系。

在Java中，UML图被广泛用于面向对象的程序设计中，常用于展示程序系统的结构和行为。

可以用于描述类与类之间的关系、类的属性和方法等。
类通常用矩形表示，类名在顶部，类的属性和方法分别在中间和底部。
实现类和类之间的关系（如继承关系、关联关系、依赖关系、聚合、组合等）时，多采用UML类图进行表示。

根据下面这个UML类图样例来展开说说Java中类与类的关系：

6.1 介绍UML类图

你可以发现每个矩形框都有三层。

矩形框：表示每个类。
第一层：类的名称，若是抽象类，字体则是斜体显示。
第二层：类的特性，通常就是字段和属性。
第三层：类的操作，通常是方法或行为。
第二、三层前面都有一些符号：
1. +：表示public修饰符
2. -：表示private修饰符
3. #：表示protected修饰符