简单工厂模式
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()); }
perate 就是单独的计算类。
如果其他的程序都想使用计算这个功能，只要在调用这个类下的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类图
你可以发现每个矩形框都有三层。
- 矩形框：表示每个类。
- 第一层：类的名称，若是抽象类，字体则是斜体显示。
- 第二层：类的特性，通常就是字段和属性。
- 第三层：类的操作，通常是方法或行为。
- 第二、三层前面都有一些符号：
+：表示public修饰符-：表示private修饰符#：表示protected修饰符
6.1.1 抽象类
表示如下：
6.1.2 接口
接口图与类图的区别：顶端有<<interface>>显示
- 第一行是接口名称
- 第二行是接口方法。
接口还有另一种表示方法，俗称棒棒糖表示法，比如图中的唐老鸭类就是实现了’讲人话’的接口
6.2 类与类之间的关系
6.2.1 继承
继承关系用空心三角形+实线来表示
6.2.2 实现接口
实现接口用空心三角形+虚线来表示
6.2.3 关联关系
当一个类 ‘知道’ 另一个类时，可以用关联(association)
关联关系用实线箭头来表示 实际还是实现extends 关键词
你看企鹅和气候两个类
6.2.3 关联关系
当一个类 ‘知道’ 另一个类时，可以用关联(association)
关联关系用实线箭头来表示 实际还是实现extends 关键词
你看企鹅和气候两个类企鹅是很特别的鸟，会游不会飞。更重要的是，它与气候有很大的关联。企鹅需要 ‘知道’ 气候的变化，需要 ‘了解’ 气候规律。
6.2.4 聚合(Aggregation)关系
类与类之间的聚合关系表示为一个类包含了另一个类的实例。这种关系被称为has-a(拥有) 关系，其中一个类是整体，另一个类是部分。聚合表示一种弱的 ‘拥有’ 关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。
在UML类图中，聚合关系用带空心菱形的实线来表示，整体指向部分。聚合关系用空心的菱形+实线箭头来表示
一个例子是汽车与车轮之间的聚合关系，其中汽车是整体，而车轮是部分。
大雁与雁群这两个类，大雁是群居动物，每只大雁都属于一个雁群，一个雁群可以有多只大雁。但是当这只大雁脱离了这个雁群，这个雁群依然能很好的继续生活下去，这就说明了大雁对象不是雁群对象的一部分。
6.2.5 合成(Composition)关系
合成（Composition，也有翻译成 ‘组合’ 的）是一种强的 ‘拥有’ 关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。
合成关系用实心的菱形+实线箭头来表示
合成关系的连线两端还有一个数字 ‘1’ 和数字 ‘2’ ，这些数被称为基数。表明这一端的类可以有几个实例，很显然，一个鸟应该有两只翅膀。
如果一个类可能有无数个实例，则就用 ‘n’ 来表示。
关联关系、聚合关系也可以有基数。
在这里鸟和其翅膀就是合成（组合）关系，因为它们是部分和整体的关系，并且翅膀和鸟的生命周期是相同的。
6.2.6 依赖关系
动物几大特征，比如有新陈代谢，能繁殖。而动物要有生命力，需要氧气、水以及食物等。也就是说，动物依赖于氧气和水。它们之间是依赖关系(Dependency)
用虚线箭头来表示
编程是一门技术，更是一门
编程是一门技术，更是一门艺术，不能只满足于写完代码运行结果正确就完事，时常考虑如何让代码更加简练，更加容易维护，容易扩展和复用，只有这样才可以真正得到提高。写出优雅的代码真的是一种很爽的事情。
