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

pranaa

于 2024-10-09 09:36:32 发布

阅读量488

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_61338837/article/details/142777159

版权

实验目的：

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));
    }
}