文章目录
前言
大家好,今天给大家介绍一下23种常见设计模式中的一种 - 工厂模式
1 . 问题引入
请用C++、Java、C#或 VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符 号，得到结果。
下面的代码实现默认认为两个操作数为Integer类型, 为了简单起见, 不引入泛型
2 . Version1
public class Version1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入数字A: ");
int A = sc.nextInt();
System.out.print("请输入你要执行的操作(+,-,*,/): ");
String str = sc.next();
System.out.print("请输入数字B: ");
int B = sc.nextInt();
if("+".equals(str)){
System.out.println(A+B);
}else if("-".equals(str)){
System.out.println(A-B);
}else if("*".equals(str)){
System.out.println(A*B);
}else if("/".equals(str)){
System.out.println(A/B);
}
}
}代码问题分析
上述代码对于初学者来说能写出来我想再正常不过了,哈哈, 我们来针对上述三点改进一下,命名还是按照A,B吧,毕竟又不是真的计算器。
3 . Version2
public class Version2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try{
System.out.print("请输入数字A: ");
int A = sc.nextInt();
System.out.print("请输入你要执行的操作(+,-,*,/): ");
String str = sc.next();
System.out.print("请输入数字B: ");
int B = sc.nextInt();
int ret = 0;
switch (str){
case "+":
ret = A+B;
break;
case "-":
ret = A-B;
break;
case "*":
ret = A*B;
break;
case "/":
if(B!=0) {
ret = A/B;
break;
}
else throw new RuntimeException("除数为0");
default:
throw new RuntimeException("没有该运算符!");
}
System.out.println("结果为: "+ret);
}catch(Exception e){
System.out.print("您的输入有误!: ");
e.printStackTrace();
}
}
}现在在看这段代码,是不是感觉没啥毛病了! 如果你没有学过面向对象编程,我没什么可说的,但是Java是面向对象编程的语言啊! 面向对象的三大特征是啥?
-
封装：封装是指将数据和行为（方法）封装在一个类中，并对外部隐藏对象的内部实现细节，只提供公共的访问方式。这样可以保护数据不被直接访问和修改，提高代码的安全性和可维护性。
-
继承：继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，子类可以复用父类的代码，并且可以在不改变父类的情况下进行扩展和修改。通过继承可以建立类之间的层次关系，提高代码的可复用性和扩展性。
-
多态：多态是指同一个方法在不同的对象上有不同的行为表现。在面向对象编程中，多态可以通过继承和接口实现。多态性可以提高代码的灵活性和可扩展性，使代码更易于维护和扩展。
一个都没用到,哈哈,这肯定是不行的,还得再改进一下!
那么如何改进呢? 先来考虑封装, 是不是可以把操作逻辑和业务逻辑单独封装为一个类?
4. Version3
package FactoryModel.Option3;
import java.util.Scanner;
/**
* 业务代码 和 计算代码实现分离! - 封装!
*/
public class Version3 {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in)){
System.out.print("请输入数字A: ");
int A = sc.nextInt();
System.out.print("请输入你要执行的操作(+,-,*,/): ");
String str = sc.next();
System.out.print("请输入数字B: ");
int B = sc.nextInt();
if(B!=0) System.out.println(Operation.getResult(A,B,str));
else throw new RuntimeException();
}catch (Exception e){
e.printStackTrace();
}
}
}
/**
* 孺鸟可教也，写得不错，这样就完全把业务和界面分离了。
* 如果你现在要我写一个Windows应用程
* 序的计算器，我就可以复用这个运算类（Operation）了
*/
class Operation{
public static int getResult(int A,int B, String oper){
int ret = 0;
switch (oper){
case "+":
ret = A+B;
break;
case "-":
ret = A-B;
break;
case "*":
ret = A*B;
break;
case "/":
ret = A/B;
}
return ret;
}
}现在如果我希望增加一个开根（sqrt）运算，你如何改？
那只需要改Operation类就行了，在switch中加一个分支就行了
问题是你要加一个平方根运算，却需要让加减乘除的运算都得来参与编译，如果你一不小心，把加法运算改成了减法，这岂不是大大的糟糕。况且改代码这件事情不符合 开放 - 封闭原则
开放 - 封闭原则（Open-Closed Principle）是面向对象设计原则之一，提出者是Bertrand Meyer。该原则指出一个软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。换句话说，一个软件实体应该通过扩展来实现新功能，而不是通过修改已有的代码来实现。
具体来说，开放 - 封闭原则要求在系统需要变化时，应该通过添加新的代码来扩展功能，而不是修改已有的代码。这样可以保持系统的稳定性，减少对已有代码的影响，同时也更容易实现代码的复用和维护。
遵循开放 - 封闭原则可以使代码更加灵活、可扩展和可维护，同时也有利于降低系统的耦合度，提高代码的可复用性。这一原则在面向对象设计中扮演着重要的角色，帮助我们设计出更加稳定和易扩展的软件系统。
这个时候就该,继承登场了!
5 . Version4
public abstract class Operation {
protected Integer A;
protected Integer B;
public Integer getA() {
return A;
}
public void setA(Integer a) {
A = a;
}
public Integer getB() {
return B;
}
public void setB(Integer b) {
B = b;
}
public abstract Integer getResult();
}class OperationAdd extends Operation{
@Override
public Integer getResult() {
return A+B;
}
}
class OperationDiv extends Operation{
@Override
public Integer getResult() {
return A/B;
}
}
class OperationMul extends Operation{
@Override
public Integer getResult() {
return A*B;
}
}
class OperationSub extends Operation{
@Override
public Integer getResult() {
return A-B;
}
}这个时候如果我们再额外添加运算是不是就变得很简单了,只需要增加一个类,继承Operation即可!
6 . 简单工厂模式
简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，属于工厂模式的一种。在简单工厂模式中，有一个工厂类负责根据客户端的需求创建相应的产品对象，而客户端无需知道具体产品的创建细节，只需要通过工厂类来获取所需的产品对象。
/**
* 简单工厂模式
*/
public class OperationFactory {
public static Operation createOperate(String oper){
Operation operation = null;
try{
switch (oper){
case "+":
operation = new OperationAdd(); // 多态
break;
case "-":
operation = new OperationSub(); // 多态
break;
case "*":
operation = new OperationMul(); // 多态
break;
case "/":
operation = new OperationDiv(); // 多态
break;
default:
throw new RuntimeException();
}
}catch(Exception e){
e.printStackTrace();
}
return operation;
}
public static void main(String[] args) {
Operation operate = OperationFactory.createOperate("+");
operate.setA(10);
operate.setB(20);
System.out.println(operate.getResult());
}
}总结
以上就是这篇博客的主要内容了,大家多多理解,下一篇博客见!
