软件体系结构实验5 （简单工厂模式、工厂模式）实现计算器

实验目的：

1）能够表述软件设计的正确性、健壮性、可复用性及可维护性等设计目标
2）能够选择合适的设计模式设计具有可扩展性及可维护性的程序

实验要求：

调试以下代码，实现程序设计的健壮性、可维护性与可扩展性；
分别使用简单工厂模式与工厂模式实现计算器（加、减、乘、除），进一步提升程序的可扩展性，并隐藏具体实现。

实验过程：

调试以下代码

初始：

java">import java.io.*;
class Calculator{				//输入两个数，相除得到结果public static void main(String[] args) throws IOException{BufferedReader b = new BufferedReader(new InputStreamReader(System.in));System.out.print("请输入数字A: ");String A = b.readLine(); //输入错误怎么办?System.out.print ("请输入数字B: ");String B = b.readLine();int C = (new Integer(A)).intValue()/(new Integer(B)).intValue(); //B=0怎么办?System.out.println ("结果是: " + C);}
}

结果：

增加健壮性：

java">import java.io.*;
import java.util.*;class CommandLineCalculator {public CommandLineCalculator(){super();}private static String getAnInputFromUser() {try{BufferedReader b = new BufferedReader(new InputStreamReader(System.in));return (b.readLine());}catch( IOException e ){System.out.println( e + " Input taken to be a single blank." );return " ";}}public static void main( String[] args ){System.out.print("请输入数字A: ");String A = getAnInputFromUser();System.out.print("请输入数字B: ");String B = getAnInputFromUser();int amountAdded = 0;while(!A.equals("stop")&!B.equals("stop")){try{int a = (new Integer(A)).intValue();   //不是整数时出错int b = (new Integer(B)).intValue();   //不是整数时出错int c = a / b;                     //b=0时出错System.out.println ("结果是: " + c);}catch( Exception e ) {   // 输入的不是整数System.out.println( "Sorry -- incorrect entry: Try again." );}System.out.print("请输入数字A: ");A = getAnInputFromUser();System.out.print("请输入数字B: ");B = getAnInputFromUser();}System.out.println("Application ends." );}
}

结果：

增加可维护性：

java">import java.io.*;interface Operation{public int getResult(int numberA, int numberB);
}class OperationAdd implements Operation{public int getResult(int numberA, int numberB){return numberA + numberB;}
}
class OperationDiv implements Operation{public int getResult(int numberA, int numberB){int result = 0;if (numberB!=0)result = numberA / numberB;else{System.out.println("除数不能为0。");System.exit(0);}return result;}
}
class OperationSub implements Operation{public int getResult(int numberA, int numberB){return numberA - numberB;}
}
class OperationMul implements Operation{public int getResult(int numberA, int numberB){return numberA * numberB;}
}class Client{public static void main(String[] args){int intNumberA=0, intNumberB=0;try{BufferedReader bufR = new BufferedReader(newInputStreamReader(System.in));System.out.print("请输入数字A：");try{intNumberA = new Integer(bufR.readLine()).intValue();}catch(Exception e){System.out.println(e);System.exit(0);}System.out.print ("请输入数字B：");try{intNumberB = new Integer(bufR.readLine()).intValue();}catch(Exception e){System.out.println(e);System.exit(0);}int intResult=0;intResult= new OperationDiv().getResult(intNumberA, intNumberB);System.out.println ("相除结果是：" + intResult);int mulResult = new OperationMul().getResult(intNumberA, intNumberB);System.out.println ("相乘结果是：" + mulResult);int addResult = new OperationAdd().getResult(intNumberA, intNumberB);System.out.println ("相加结果是：" + addResult);int subResult = new OperationSub().getResult(intNumberA, intNumberB);System.out.println ("相减结果是：" + subResult);}catch(Exception e){System.out.println(e);}}
}

结果：

工厂模式：

工厂方法模式将创建对象的职责委托给多个工厂子类中的某一个，但客户端在使用时不需要知道是哪一个工厂子类。这进一步提升了系统的可扩展性。

步骤：

定义一个操作接口 Operation。
为每种操作实现具体的类（加、减、乘、除）。
定义一个工厂接口 OperationFactory。
为每种操作实现一个具体的工厂类。

代码：

java">// Step 1: 定义操作接口  
interface Operation2 {double calculate(double a, double b);
}// Step 2: 实现具体的操作类  
class AddOperation2 implements Operation2 {@Overridepublic double calculate(double a, double b) {return a + b;}
}class SubtractOperation2 implements Operation2 {@Overridepublic double calculate(double a, double b) {return a - b;}
}class MultiplyOperation2 implements Operation2 {@Overridepublic double calculate(double a, double b) {return a * b;}
}class DivideOperation2 implements Operation2 {@Overridepublic double calculate(double a, double b) {if (b == 0) {throw new ArithmeticException("Cannot divide by zero");}return a / b;}
}// Step 3: 定义工厂接口  
interface OperationFactory2 {Operation createOperation();
}// Step 4: 实现具体的工厂类  
class AddOperationFactory implements OperationFactory2 {@Overridepublic Operation createOperation() {return new AddOperation();}
}class SubtractOperationFactory implements OperationFactory2 {@Overridepublic Operation createOperation() {return new SubtractOperation();}
}class MultiplyOperationFactory implements OperationFactory2 {@Overridepublic Operation createOperation() {return new MultiplyOperation();}
}class DivideOperationFactory implements OperationFactory2 {@Overridepublic Operation createOperation() {return new DivideOperation();}
}// 客户端代码  
public class cal {public static void main(String[] args) {double a = 10.0;double b = 5.0;
System.out.println("a: "+a+" b: "+b);OperationFactory2 addFactory = new AddOperationFactory();Operation add = addFactory.createOperation();System.out.println("Addition: " + add.calculate(a, b));OperationFactory2 subtractFactory = new SubtractOperationFactory();Operation subtract = subtractFactory.createOperation();System.out.println("Subtraction: " + subtract.calculate(a, b));OperationFactory2 multiplyFactory = new MultiplyOperationFactory();Operation multiply = multiplyFactory.createOperation();System.out.println("Multiplication: " + multiply.calculate(a, b));OperationFactory2 divideFactory = new DivideOperationFactory();Operation divide = divideFactory.createOperation();System.out.println("Division: " + divide.calculate(a, b));}
}

结果：

简单工厂模式：

简单工厂模式通过一个工厂类来创建具体的产品对象，但所有产品类都需要遵循相同的接口或继承自相同的基类。

步骤：

定义一个操作接口 Operation。

为每种操作实现具体的类（加、减、乘、除）。

创建一个工厂类 OperationFactory 来生成具体的操作对象。

代码：

java">// Step 1: 定义操作接口  
interface Operation {double calculate(double a, double b);
}// Step 2: 实现具体的操作类  
class AddOperation implements Operation {@Overridepublic double calculate(double a, double b) {return a + b;}
}class SubtractOperation implements Operation {@Overridepublic double calculate(double a, double b) {return a - b;}
}class MultiplyOperation implements Operation {@Overridepublic double calculate(double a, double b) {return a * b;}
}class DivideOperation implements Operation {@Overridepublic double calculate(double a, double b) {if (b == 0) {throw new ArithmeticException("Cannot divide by zero");}return a / b;}
}// Step 3: 创建工厂类  
class OperationFactory {public static Operation createOperation(String operationType) {switch (operationType) {case "add":return new AddOperation();case "subtract":return new SubtractOperation();case "multiply":return new MultiplyOperation();case "divide":return new DivideOperation();default:throw new IllegalArgumentException("Unknown operation type: " + operationType);}}
}// 客户端代码  
public class calsimple {public static void main(String[] args) {double a = 10.0;double b = 5.0;
System.out.println("a: "+ a+ " b: "+ b);Operation add = OperationFactory.createOperation("add");System.out.println("Addition: " + add.calculate(a, b));Operation subtract = OperationFactory.createOperation("subtract");System.out.println("Subtraction: " + subtract.calculate(a, b));Operation multiply = OperationFactory.createOperation("multiply");System.out.println("Multiplication: " + multiply.calculate(a, b));Operation divide = OperationFactory.createOperation("divide");System.out.println("Division: " + divide.calculate(a, b));}
}

结果：

心得：

本次实验我学习到简单工厂模式和工厂模式，通过运用简单工厂模式和工厂模式，我能够轻松地添加新的运算功能，而无需修改现有的代码。这大大提高了代码的灵活性和可扩展性。

同时使用这两个模式增强了代码的可读性和可维护性，使用设计模式使得代码结构更加清晰，职责更加明确。工厂类负责创建产品类实例，运算类负责执行具体的运算。这种分离使得代码更加易于理解和维护。

对于上述实验通过比较得到：

1.简单工厂模式：通过一个工厂类来创建所有产品对象，简单易用，但增加新产品时需要修改工厂类，违反了开闭原则（对扩展开放，对修改关闭）。

2.工厂方法模式：每个产品类对应一个工厂类，扩展新产品时只需添加新的产品类和对应的工厂类，无需修改已有代码，更好地遵循了开闭原则。