利用Java编写两个数简单的运算

•  客户需求
  • 小数运算
    • 因此有关的变量采用实型变量
  • 加、减、乘和除法
    • 读取用户的选择，采取读取字符串的方式
  • 连续执行多次计算
    • 采用循环实现连续计算
  • 用户可以中断
    • 读取用户的选择，使用条件判断和break语句实现用户中途中止
• 实现方式
  • 每次循环依次读入第一个操作数和第二个操作数，然后读入操作符
  • 程序根据操作符对二个操作数进行计算，并将结果输出到屏幕
  • 最后询问用户是否继续。

3．界面设计

• 这是设计的界面（执行结果）

原理与方法

1.Java的数据类型

• 基本数据类型：boolean、byte、short、int、long、float、double、char。

• 常用数据类型：String

2.Java从命令行输入、输出数据

• 从命令行输入数据

• 可以使用Scanner类创建一个对象：Scanner reader=new Scanner(System.in);
• 通过reader对象调用下列方法，读取用户在命令行（例如，MS-DOS窗口）输入的各种基本类型数据： nextBoolean()、nextByte()、nextShort()、nextInt()、nextLong()、nextFloat()、nextDouble()。

• 从命令行输出数据

• 用System.out.println()或System.out.print()可输出串值、表达式的值，二者的区别是前者输出数据后换行，后者不换行。
• 允许使用并置符号：“+”将变量、表达式或一个常数值与一个字符串并置一起输出，如：

System.out.println(m+"个数的和为"+sum);

3.String类的常用方法

• equals():比较两个字符串内容是否一致。

• equalsIgnoreCase():忽略大小写，比较两个字符串内容是否一致。

package C;
import java.util.Scanner;
public class D {

    public static void main(String[] args) {
        //创建一个Scanner对象来读取用户的输入
        Scanner sc = new Scanner(System.in);
        char operator;
        double num1, num2, result;
        String exitChoice = null;

        do {
            //提示用户输入一个数
            System.out.print("请输入第一个数:");
            num1 = sc.nextDouble();
            //提示用户输入二个运算符
            System.out.print("请输入第二个数:");
            num2 = sc.nextDouble();
            //提示用户输入一个运算符
            System.out.print("请输入运算符:（+，-，*，/,%,^）");
            operator = sc.next().charAt(0);
            //根据运算符进行运算
            switch (operator) {
                case '+':
                    result = num1 + num2;
                    break;
                case '-':
                    result = num1 - num2;
                    break;
                case '*':
                    result = num1 * num2;
                    break;
                case '/':
                    if (num2 == 0) {
                        System.out.println("除数不能为0，请重新输入！");
                        continue;
                    }
                    result = num1 / num2;
                case '%':
                    result=num1%num2;
                    break;
                case '^':
                    result=Math.pow(num1,num2);
                    break;
                default:
                    System.out.println("无效的运算符，请重新输入！");
                    continue;
            }
            // 输出结果
            System.out.println("结果是: " + result);
          

            // 询问是否退出或继续计算
            System.out.print("请问是否要退出(y)或继续计算(n)?: ");
            exitChoice = sc.next();

        } while (!"y".equalsIgnoreCase(exitChoice));

        sc.close();
        System.out.println("程序已退出。");
    }
}

这个程序会提示用户输入两个数、一个运算符，然后根据输入的运算符进行相应的运算，并输出结果。之后，程序会询问用户是否要退出，根据用户的输入（y或n）来决定是否结束程序。

在这个改进后的代码中，我们创建了一个ArrayList<String>类型的变量history来存储每次计算的结果。在每次计算完成后，我们都会将计算的过程和结果作为字符串添加到history列表中。

然后，在每次计算后，我们输出历史记录，并询问用户是否要查看历史记录、退出程序或继续计算。如果用户选择查看历史记录，我们就打印出整个history列表。如果用户选择退出，我们就退出循环并关闭程序。如果用户选择继续计算，我们就回到循环的开始，等待用户输入新的计算参数。

package C;
import java.util.Scanner;
import java.util.ArrayList;
public class D {

    public static void main(String[] args) {
        //创建一个Scanner对象来读取用户的输入
        Scanner sc = new Scanner(System.in);
        char operator;
        double num1, num2, result;
        String exitChoice = null;
        // 用于存储历史记录
        ArrayList<String> history = new ArrayList<>();

        do {
            //提示用户输入一个数
            System.out.print("请输入第一个数:");
            num1 = sc.nextDouble();
            //提示用户输入二个运算符
            System.out.print("请输入第二个数:");
            num2 = sc.nextDouble();
            //提示用户输入一个运算符
            System.out.print("请输入运算符:（+，-，*，/,%,^）");
            operator = sc.next().charAt(0);
            //根据运算符进行运算
            switch (operator) {
                case '+':
                    result = num1 + num2;
                    break;
                case '-':
                    result = num1 - num2;
                    break;
                case '*':
                    result = num1 * num2;
                    break;
                case '/':
                    if (num2 == 0) {
                        System.out.println("除数不能为0，请重新输入！");
                        continue;
                    }
                    result = num1 / num2;
                case '%':
                    result=num1%num2;
                    break;
                case '^':
                    result=Math.pow(num1,num2);
                    break;
                default:
                    System.out.println("无效的运算符，请重新输入！");
                    continue;
            }
            // 输出结果并添加到历史记录
            System.out.println("结果是: " + result);
            history.add(num1 + " " + operator + " " + num2 + " = " + result);

            // 显示历史记录选项
            System.out.println("历史记录: " + history);

            // 询问是否查看历史记录、退出或继续计算
            System.out.print("请问是否要查看历史记录(h)、退出(y)或继续计算(n)?: ");
            exitChoice = sc.next();

            if ("h".equalsIgnoreCase(exitChoice)) {
                // 打印全部历史记录
                System.out.println("历史记录: " + history);
            }

        } while (!"y".equalsIgnoreCase(exitChoice));

        sc.close();
        System.out.println("程序已退出。");
    }
}

要创新这个Java代码，我们可以考虑以下几个方向：

1.增加高级数学功能：

引入三角函数（sin, cos, tan等）。
引入指数和对数函数（exp, log等）。
支持阶乘运算。

2.实现表达式解析：

允许用户输入一个完整的数学表达式，如 "3 + 4 * 2"，并解析计算。
使用栈（Stack）等数据结构来实现表达式求值算法。

使用Java的枚举（Enum）来定义运算符：

这样可以使代码更加清晰，并且增加运算符的扩展性。

3.优化用户界面：

使用命令行参数或配置文件来设置默认选项。
增加颜色输出或使用简单的文本界面库来美化输出。

4.支持历史记录：

允许用户查看之前的计算结果。
可以使用List或Deque来存储历史记录。

5.实现错误处理：

当用户输入非法字符或格式不正确的数字时，提供更详细的错误信息。
使用try-catch块捕获潜在的异常，如InputMismatchException。

6.集成外部库：

使用Apache Commons Math或JSci等数学库来增强计算能力。以下是一个简单的创新示例，实现一个表达式解析器来解析简单的加减乘除表达式：

import java.util.Scanner;
import java.util.Stack;

public class AdvancedCalculatorProgram {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String expression;
        double result;
        String exitChoice;

        do {
            // 输入表达式
            System.out.print("请输入表达式 (例如: 3 + 4 * 2): ");
            expression = scanner.nextLine();

            // 解析并计算表达式
            result = evaluateExpression(expression);

            // 输出结果
            System.out.println("结果是: " + result);

            // 询问是否退出
            System.out.print("请问是否要退出？(y/n): ");
            exitChoice = scanner.next();

        } while (!"y".equalsIgnoreCase(exitChoice));

        scanner.close();
        System.out.println("程序已退出。");
    }

    // 解析表达式的函数（这里简化实现，只处理加减乘除和括号）
    private static double evaluateExpression(String expression) {
        Stack<Double> values = new Stack<>();
        Stack<Character> operators = new Stack<>();

        for (char ch : expression.toCharArray()) {
            if (Character.isDigit(ch)) {
                // 处理数字（这里简化处理，假设数字之间不会有空格）
                StringBuilder numBuilder = new StringBuilder();
                while (Character.isDigit(ch) || ch == '.') {
                    numBuilder.append(ch);
                    if (scanner.hasNext()) {
                        ch = scanner.next().charAt(0);
                    } else {
                        break;
                    }
                }
                double num = Double.parseDouble(numBuilder.toString());
                values.push(num);
            } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                // 处理运算符（考虑优先级）
                while (!operators.isEmpty() && hasPrecedence(ch, operators.peek())) {
                    char op = operators.pop();
                    double val2 = values.pop();
                    double val1 = values.pop();
                    values.push(applyOp(val1, val2, op));
                }
                operators.push(ch);
            } else if (ch == '(') {
                // 处理左括号，直接入栈
                operators.push(ch);
            } else if (ch == ')') {
                // 处理右括号，计算括号内的表达式
                while (!operators.isEmpty() && operators.peek() != '(') {
                    char op = operators.pop();
                    double val2 = values.pop();
                    double val1 = values.pop();
                    values.push(applyOp(val1, val2, op));
                }
                // 弹出左括号
                operators.pop();
            }
        }

        // 处理剩余的操作符
        while (!operators.isEmpty()) {
            char op = operators.pop();
            double val2 = values.pop();
            double val1 = values.pop();
            values.push(applyOp(val1, val2, op));
        }

        // 栈顶元素即为最终结果
        return values.pop();
    }

    // 判断运算符优先级
    private static boolean hasPrecedence(char op1, char op2) {
        if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) {
            return false;
        }
        return true;
    }

    // 应用运算符
    private static double applyOp(double a, double b, char op) {
        switch (op) {
            case '+': return a + b;
            case '-': return a - b;
            case '*': return a * b;
            case '/':
                if (b == 0) {
                    throw new IllegalArgumentException("除数不能为0");
                }
                return a / b;
        }
        return 0;
    }
}

注意，上述代码是一个非常简化的表达式解析器实现，仅用于演示目的。在实际应用中，你可能需要处理更复杂的表达式、错误处理、空格和多个数字之间的分隔符等问题。此外，对于更复杂的数学运算和函数，你可能需要引入更强大的数学库。