工厂模式
开始
- 使用C++,Java，C#等任意一种面向对象语言实现一个计算器控制台程序
- 要求： 输入二个数和运算符，输出结果
实现
简单实现
一个类搞定
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package pers.fulsun.study.simple_factory;
import java.util.Scanner;
/**
* <p>
*
* @author fulsun
* @date 7/12/2021
*/
public class _01Start {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("第一个数:");
Double num1 = scanner.nextDouble();
System.out.println("第二个数:");
Double num2 = scanner.nextDouble();
System.out.println("操作符号(+，-，*，/):");
String num3 = scanner.next();
switch (num3) {
case "+":
System.out.println(num1 + num2);
break;
case "-":
System.out.println(num1 - num2);
break;
case "*":
System.out.println(num1 * num2);
break;
case "/":
if (num2 == 0) {
System.out.println("除数不能为0");
} else {
System.out.println("结果是："+ (num1 / num2));
}
break;
default:
System.out.println("计算失败");
}
}
}
面向对象编程
上面的方式不容易维护，扩展，复用
- 降低业务逻辑和界面的耦合
Opertion 运算类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24class Operation {
public Double getResult(double numA, double numB, String operate) {
double result = 0d;
switch (operate) {
case "+":
result = numA + numB;
break;
case "-":
result = numA - numB;
break;
case "*":
result = numA * numB;
break;
case "/":
result = numA / numB;
break;
}
return result;
}
}客户端
1
2
3
4
5
6
7
8
9
10
11public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("第一个数:");
Double num1 = scanner.nextDouble();
System.out.println("第二个数:");
Double num2 = scanner.nextDouble();
System.out.println("操作符号(+，-，*，/):");
String operate = scanner.next();
Double result = new Operation().getResult(num1, num2, operate);
System.out.println("结果是：" + result);
}这里用到了封装， Opertion 类可以被复用
灵活与扩展
使用上继承和多态
如果想添加一个平凡根的功能：
- switch多添加一个分支做计算
添加平方根的功能，会让原有的运算都参与编译，如果原有部分代码被改动了，这种方式有风险。
应该吧加减乘除运算分离，修改其中一个不影响其他的
Operation变成一个运算接口，不同的运算去实现
1
2
3
4
5
6
7
8
9
10
11interface Operation1 {
public double getResult(double numA,double numB);
}
class AddOperation implements Operation1 {
public double getResult(double numA, double numB) {
return numA + numB;
}
}1
Double result = new AddOperation().getResult(num1, num2);
如何让计算器知道该调用那个算法
通过case对运算符进行判断，创建对应的Operation 实现类
1
2
3
4
5
6
7Operation1 oper = null;
switch (operate) {
case "+":
oper = new AddOperation();
break;
}
简单工厂模式
上面通过case创建实例对象的方法，可以使用使用了简单工厂模式，这部分是很容易变化的过程，应该考虑通过一个单独的类来创建实例
简单工厂模式：定义一个用于创建对象的接口。
1
2
3
4
5
6
7
8
9
10
11
12
13class OperationFactory{
public static Operation1 createOperation(String operate){
Operation1 oper = null;
switch (operate) {
case "+":
oper = new AddOperation();
break;
}
return oper;
}
}1
double result = OperationFactory.createOperation(operate).getResult(num1, num2);
简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。
它存 在的目的很简单：定义一个用于创建对象的接口。
先来看看它的组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由 一个具体类实现。
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽 象类来实现。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当增加了新的运算规则的时候，实现Operation类后在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则 的。
工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。 由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了， 也累坏了我们这些程序员:( 于是工厂方法模式作为救世主出现了。
工厂方法模式
工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。
这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。
它的组成：
- 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须 实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。
- 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体 产品的对象。
- 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类 或者接口来实现。
- 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类 来实现。
用类图来清晰的表示下的它们之间的关系：
可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
因为如果不能避免这种情况，可以考虑使 用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：
- 即对于产品树上类似的种类 （一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。
小结
- 工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。
- 那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情 况下你可以考虑使用工厂方法模式：
- 当客户程序不需要知道要使用对象的创建过程。
- 客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。
- 简单工厂模式与工厂方法模式真正的避免了代码的改动了？
- 没有。在简单工厂模式中， 新产品的加入要修改工厂角色中的判断语句；
- 而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。
- 而且产品 对象创建条件的改变必然会引起工厂角色的修改。 面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中 完美的体现了出来。