（Java）基於GUI的計算器算法

Question

在進入我的問題之前，我想指出的是，實際上我主要不需要編碼方面的幫助，我已經考慮了好幾天了，所以也許這不完全是基於編程的問題。

經過大約兩年的編程后，我決定在幾天前恢復知識。 我為計算器編寫了一個基於擺動的GUI，並且能夠為+，*操作創建一個有效的計算器，但僅適用於一位數字。 您可以在下面看到代碼。

我現在的問題是，你們中沒有人知道一種算法，該算法可用於與具有更多位數的數字的方程式使用相同的GUI嗎？

編寫代碼應該不是問題，但是不幸的是，我無法找出有用的東西。

我希望有創造性的解決方案，即使這只是一個基本的想法，我也很樂意加入它的進一步發展:)

馬克斯

碼：

Main.java：

public class Main {

    public static void main(String[] args) {
        new CalculatorController();

    }
}

CalculatorController.java：

public class CalculatorController {

    private CalculatorView view;
    private NumberAction nmbAction;
    private OperatorAction opAction;
    private CalcObject currentValue, savedValue;

    CalculatorController() {
        currentValue = new CalcObject();
        savedValue = new CalcObject();
        nmbAction = new NumberAction(this);
        opAction = new OperatorAction(this);
        view = new CalculatorView(this);
        view.setSize(250, 220);
        view.setVisible(true);
    }

    public void printResult(double result) {
        view.getCALCULATION().setText(String.valueOf(result));
    }

    public CalculatorView getView() {
        return view;
    }

    public NumberAction getNmbAction() {
        return nmbAction;
    }

    public OperatorAction getOpAction() {
        return opAction;
    }

    public CalcObject getCurrentValue() {
        return currentValue;
    }

    public CalcObject getSavedValue() {
        return savedValue;
    }

    public void setCurrentValue(CalcObject currentValue) {
        String str = currentValue.getOperator();
        this.currentValue.setOperator(str);
        this.currentValue.setNumber(currentValue.getNumber());
    }

    public void setSavedValue(CalcObject stripeValue) {
        String str = stripeValue.getOperator();
        this.savedValue.setOperator(str);
        this.savedValue.setNumber(stripeValue.getNumber());
    }
}

CalculatorView.java：

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;

public class CalculatorView extends JFrame {

    private String equation = "";
    private CalcObject object = new CalcObject();
    private JPanel pane;
    private JPanel contentPane;
    private JTextField CALCULATION;
    private JButton NMB_0;
    private JButton NMB_1;
    private JButton NMB_2;
    private JButton NMB_3;
    private JButton NMB_4;
    private JButton NMB_5;
    private JButton NMB_6;
    private JButton NMB_7;
    private JButton NMB_8;
    private JButton NMB_9;
    private JButton CALC;
    private JButton MULTIPLY;
    private JButton DIVIDE;
    private JButton ADD;
    private JButton SUBTRACT;

    public CalculatorView(CalculatorController controller) {

        setDefaultCloseOperation(CalculatorView.EXIT_ON_CLOSE);
        pane = new JPanel(new FlowLayout());
        setContentPane(pane);

        CALCULATION = new JTextField();
        CALCULATION.setColumns(16);
        pane.add(CALCULATION);

        contentPane = new JPanel(new GridLayout(0, 3));
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        pane.add(contentPane);

        NMB_1 = new JButton(controller.getNmbAction());
        NMB_1.setText("1");
        contentPane.add(NMB_1);

        NMB_2 = new JButton(controller.getNmbAction());
        NMB_2.setText("2");
        contentPane.add(NMB_2);

        NMB_3 = new JButton(controller.getNmbAction());
        NMB_3.setText("3");
        contentPane.add(NMB_3);

        NMB_4 = new JButton(controller.getNmbAction());
        NMB_4.setText("4");
        contentPane.add(NMB_4);

        NMB_5 = new JButton(controller.getNmbAction());
        NMB_5.setText("5");
        contentPane.add(NMB_5);

        NMB_6 = new JButton(controller.getNmbAction());
        NMB_6.setText("6");
        contentPane.add(NMB_6);

        NMB_7 = new JButton(controller.getNmbAction());
        NMB_7.setText("7");
        contentPane.add(NMB_7);

        NMB_8 = new JButton(controller.getNmbAction());
        NMB_8.setText("8");
        contentPane.add(NMB_8);

        NMB_9 = new JButton(controller.getNmbAction());
        NMB_9.setText("9");
        contentPane.add(NMB_9);

        MULTIPLY = new JButton(controller.getOpAction());
        MULTIPLY.setText("*");
        contentPane.add(MULTIPLY);

        NMB_0 = new JButton(controller.getNmbAction());
        NMB_0.setText("0");
        contentPane.add(NMB_0);

        DIVIDE = new JButton(controller.getOpAction());
        DIVIDE.setText("/");
        contentPane.add(DIVIDE);
        DIVIDE.setEnabled(false);

        ADD = new JButton(controller.getOpAction());
        ADD.setText("+");
        contentPane.add(ADD);

        CALC = new JButton(controller.getOpAction());
        CALC.setText("=");
        contentPane.add(CALC);

        SUBTRACT = new JButton(controller.getOpAction());
        SUBTRACT.setText("-");
        contentPane.add(SUBTRACT);
        SUBTRACT.setEnabled(false);
    }

    public String getEquation() { return equation; }

    public void setEquation(String equation) { this.equation = equation;      }

    public JTextField getCALCULATION() {
        return CALCULATION;
    }
}

OperatorAction.java：

import javax.swing.*;
import java.awt.event.ActionEvent;

public class OperatorAction extends AbstractAction {

    private String operator;
    private CalculatorController controller;

    OperatorAction(CalculatorController controller) {
        this.controller = controller;
        this.operator = "";
    }

    public void actionPerformed(ActionEvent e) {
        JButton button = (JButton)e.getSource();
        this.operator = button.getText();
         controller.getView().setEquation(controller.getView().getEquation().concat(this.operator));
        controller.getView().getCALCULATION().setText(controller.getView().getEquation());

        controller.getCurrentValue().setOperator(operator);

        if (controller.getCurrentValue().getOperator() == "=") {
            if (controller.getSavedValue().getOperator() == "+") {
                controller.printResult(Double.parseDouble(controller.getSavedValue().getNumber()) + Double.parseDouble(controller.getCurrentValue().getNumber()));
            } else {
                controller.printResult(Double.parseDouble(controller.getCurrentValue().getNumber()));
            }
            controller.getView().setEquation("");
            controller.getCurrentValue().setNumber("0");
            controller.getSavedValue().setNumber("0");
            controller.getCurrentValue().setOperator("");
            controller.getSavedValue().setOperator("");
        }
    }
}

NumberAction.java：

import javax.swing.*;
import java.awt.event.ActionEvent;

public class NumberAction extends AbstractAction {

    private String number;
    private CalculatorController controller;

    NumberAction(CalculatorController controller) {
        this.controller = controller;
        this.number = "";
    }

    public void actionPerformed(ActionEvent e) {
        JButton button = (JButton)e.getSource();
        this.number = button.getText();
        controller.getView().setEquation(controller.getView().getEquation().concat(this.number));
        controller.getView().getCALCULATION().setText(controller.getView().getEquation());

        if (controller.getSavedValue().getOperator() == "") {
            if (controller.getCurrentValue().getOperator() == "") {
                controller.getCurrentValue().setNumber(number);
            }
            if (controller.getCurrentValue().getOperator() == "*") {
                controller.getCurrentValue().setNumber(String.valueOf(Double.parseDouble(    controller.getCurrentValue().getNumber()) * Double.parseDouble(number)));
                controller.setSavedValue(controller.getCurrentValue());
            }
            if (controller.getCurrentValue().getOperator() == "+") {
                controller.setSavedValue(controller.getCurrentValue());
                controller.getCurrentValue().setNumber(number);
            }
        } else {
            if (controller.getCurrentValue().getOperator() == "*") {
                controller.getCurrentValue().setNumber(String.valueOf(Double.parseDouble(    controller.getCurrentValue().getNumber()) * Double.parseDouble(number)));
            }
            if (controller.getCurrentValue().getOperator() == "+") {
                controller.getCurrentValue().setNumber(String.valueOf(Double.parseDouble(controller.getSavedValue().getNumber()) + Double.parseDouble(controller.getCurrentValue().getNumber()) + Double.parseDouble(number)));
                controller.getSavedValue().setOperator("");
            }
        }
    }
}

CalcObject.java：

public class CalcObject {
    private String NUMBER;
    private String OPERATOR;

    CalcObject() {
        NUMBER = "0";
        OPERATOR = "";
    }

    CalcObject(String number, String operator) {
        NUMBER = number;
        OPERATOR = operator;
    }

    public void setNumber(String number) { NUMBER = number; }

    public void setOperator(String operator) { OPERATOR = operator; }

    public String getNumber() { return NUMBER; }

    public String getOperator() { return OPERATOR; }
}

好吧，在再次檢查程序時，我發現，這種用於單數數字的算法既不能正常工作，但我的問題仍然相同。 我也很樂意提出一些意見或想法，以使其變得更輕松，更流暢或更好。

Answer 1

另一個建議：創建一個分析和評估字符串的計算器是否更容易。 網上有很多示例，因此這應該是一個有趣而又不太困難的任務，特別是因為您要提高自己的編程技能（您甚至可以實現並提供多個解析器）。

UI將具有創建字符串的簡單任務，即每個按鈕僅向當前方程式字符串添加一個字符，然后=按鈕將運行解析器。

Answer 2

對於多位數字，應使用字符串，以便用戶單擊數字時，該數字將附加到字符串。 使用JTextField，您可以將鍵入與單擊數字按鈕結合起來。

對於簡單的情況，您可以將字符串轉換為數字，並在用戶單擊+-* /時將其存儲為“以前的值”。 您還需要一個字段來存儲操作。 在第二個操作（或“ =”）上，您將使用先前的值，存儲的運算和當前值來計算結果。

在更高級的級別上，可以添加括號按鈕。 輸入/退出括號時，您可以使用一堆先前的數字來推送和彈出，而不是使用單個先前的數字。

在專家級別，您可以使用解析器和語法。 這樣，您將擁有自己的編程語言。 您將學到很多東西，並且能夠從輸入字符串中計算出任何有效的表達式。 例如參見這里 。