我怎樣才能只用一種方法制作這個計算器？

Question

我正在嘗試制作這個計算器，我可以使用 4 種方法來制作它，一種用於加法，一種用於減法......但我想讓它盡可能簡單。 如何使用一種方法執行 4 個主要操作，然后在 static main 中調用它？

package com.company;

import java.util.Scanner;

public class Main {
    final static String first = "first number: ";
    final static String sec = "second number: ";

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("what do you want to use? (multiply (input *), divide (input /), subtract (input -), addition (input +)");
        String input = scanner.nextLine();
        double answer = calculation(input);                 ----------------------
        System.out.println(answer);
    }
    public static double calculation(double element){       ----------------------
        Scanner scanner = new Scanner(System.in);
        System.out.println(first);
        double firstInput = scanner.nextDouble();
        System.out.println(sec);
        double secInput = scanner.nextDouble();
        return firstInput element secInput;                 ----------------------
    }
}

我可以將element更改為 ( + - * / ) 嗎？ （ ------------------ 部分是我有問題）

Answer 1

您可能想看看 OOP 原理，使用 inheritance 和多態性，您應該能夠在接口中定義一個方法並在您的類中定義它的多個實現，因此您可以擁有一個帶有執行方法的計算接口然后您使用像 Sum 這樣的 class 實現該接口，其中 execute 方法執行實際總和。

public interface Calculation {
    Double execute(Double a, Double b);
}

public class Sum implements Calculation {
    @Override
    public Double execute(Double a, Double b) {
        return a+b;
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("what do you want to use? (multiply => *, divide => /, subtract => -, addition => +");
        String input = scanner.nextLine();
        Calculation calculation;
        if (input.equals("+")) calculation = new Sum();
        else calculation = new Sum();// Just initializing calculation to avoid compilation error
        double answer = execute(calculation);
    }

    private static double execute(Calculation calculation){
        Scanner scanner = new Scanner(System.in);
        double firstInput = scanner.nextDouble();
        System.out.println(firstInput);
        double secInput = scanner.nextDouble();
        System.out.println(secInput);
        return calculation.execute(firstInput, secInput);
    }
}

Answer 2

您可以使用enum和lambda函數來執行它。 這種方法使您可以輕松地將操作添加到代碼中，而無需重寫計算方法。 首先使用Scanner和try-with-resources或在不再需要Scanner后調用scanner.close() 。 那么最好不要創建兩個Scanner object，而是將您的輸入部分合並到一種方法中（如果您仍想使用兩個Scanner實例，請記住將System.in包裝在裝飾器中以防止其關閉）。 您也可以添加一些驗證以防止輸入錯誤（並讓用戶嘗試再次輸入數據）。 主要思想是為每個操作創建一個包含BiFunction的枚舉，並將其應用於您的一對數字。 它可能看起來像這樣：

public class Main {

    private final static String first = "first number: ";
    private final static String sec = "second number: ";

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            String operationTypes = Arrays.stream(OperationType.values())
                    .map(type -> String.format("%s (input %s)", type.toString(), type.sign))
                    .collect(Collectors.joining("(", ", ", ")"));
            System.out.println("what do you want to use? " + operationTypes);
            String input = scanner.nextLine();
            System.out.println(first);
            double firstInput = scanner.nextDouble();
            System.out.println(sec);
            double secInput = scanner.nextDouble();
            OperationType operationType = OperationType.fromSign(input).orElseThrow();
            double answer = calculation(operationType, firstInput, secInput);
            System.out.println(answer);
        }
    }

    public static double calculation(OperationType operationType, double firstInput, double secInput) {
        return operationType.operation.apply(firstInput, secInput);
    }

    enum OperationType {

        ADD("+", Double::sum),
        SUBTRACT("-", (a, b) -> a - b),
        MULTIPLY("*", (a, b) -> a * b),
        DIVIDE("/", (a, b) -> a / b);

        String sign;
        BiFunction<Double, Double, Double> operation;

        OperationType(String sign, BiFunction<Double, Double, Double> operation) {
            this.sign = sign;
            this.operation = operation;
        }

        public static Optional<OperationType> fromSign(String sign) {
            return Arrays.stream(OperationType.values())
                    .filter(operationType -> operationType.sign.equals(sign))
                    .findAny();
        }

        @Override
        public String toString() {
            return this.name().toLowerCase();
        }
    }

}