软件体系结构 实验5 (简单工厂模式、工厂模式)实现计算器
实验目的:
- 1)能够表述软件设计的正确性、健壮性、可复用性及可维护性等设计目标
- 2)能够选择合适的设计模式设计具有可扩展性及可维护性的程序
实验要求:
- 调试以下代码,实现程序设计的健壮性、可维护性与可扩展性;
- 分别使用简单工厂模式与工厂模式实现计算器(加、减、乘、除),进一步提升程序的可扩展性,并隐藏具体实现。
实验过程:
调试以下代码
初始:
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);
}
}
结果:
增加健壮性:
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." );
}
}
结果:
增加可维护性:
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(new
InputStreamReader(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。
- 为每种操作实现一个具体的工厂类。
代码:
// Step 1: 定义操作接口
interface Operation2 {
double calculate(double a, double b);
}
// Step 2: 实现具体的操作类
class AddOperation2 implements Operation2 {
@Override
public double calculate(double a, double b) {
return a + b;
}
}
class SubtractOperation2 implements Operation2 {
@Override
public double calculate(double a, double b) {
return a - b;
}
}
class MultiplyOperation2 implements Operation2 {
@Override
public double calculate(double a, double b) {
return a * b;
}
}
class DivideOperation2 implements Operation2 {
@Override
public 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 {
@Override
public Operation createOperation() {
return new AddOperation();
}
}
class SubtractOperationFactory implements OperationFactory2 {
@Override
public Operation createOperation() {
return new SubtractOperation();
}
}
class MultiplyOperationFactory implements OperationFactory2 {
@Override
public Operation createOperation() {
return new MultiplyOperation();
}
}
class DivideOperationFactory implements OperationFactory2 {
@Override
public 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 来生成具体的操作对象。
代码:
// Step 1: 定义操作接口
interface Operation {
double calculate(double a, double b);
}
// Step 2: 实现具体的操作类
class AddOperation implements Operation {
@Override
public double calculate(double a, double b) {
return a + b;
}
}
class SubtractOperation implements Operation {
@Override
public double calculate(double a, double b) {
return a - b;
}
}
class MultiplyOperation implements Operation {
@Override
public double calculate(double a, double b) {
return a * b;
}
}
class DivideOperation implements Operation {
@Override
public 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.工厂方法模式:每个产品类对应一个工厂类,扩展新产品时只需添加新的产品类和对应的工厂类,无需修改已有代码,更好地遵循了开闭原则。
原文地址:https://blog.csdn.net/m0_61338837/article/details/142777159
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!