Question

在我跳到我的问题之前我想注意，实际上我并不主要需要编码方面的帮助，我几天都在考虑这个问题，所以这可能不是一个基于编程的问题。 / p>

在编程缺席大约2年后，我决定在几天前更新我的知识。我为计算器编写了一个基于swing的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

另一个建议：如果可能更容易创建一个解析和评估字符串的计算器。这个on the net有很多例子，所以这应该是一个有趣且不太难的任务，特别是因为你正试图提高你的编程技巧（你甚至可以实现并提供几个解析器来解决这个问题））。

然后，UI将具有创建字符串的简单任务，即每个按钮只向当前的方程字符串添加一个字符，然后=按钮将运行解析器。

Answer 2

对于多位数字，您应该使用一个字符串，这样当用户点击一个数字时，该数字将附加到字符串。使用JTextField，您可以组合键入并单击数字按钮。

对于简单的情况，您可以将字符串转换为数字，并在用户单击+ - * /时将其存储为“之前的值”。您还需要一个字段来存储操作。在第二个操作（或“=”）上，您将使用先前的值，存储的操作和当前值来计算结果。

在更高级别，您可以添加括号按钮。在进入/退出括号时，您可以使用一堆先前的数字来推送和弹出它们，而不是单个先前的数字。

在专家级别，您可以使用解析器和语法。有了它，你将拥有自己的编程语言。您将学到很多东西，并且您将能够从输入字符串计算任何有效的表达式。例如，请参阅here。

（Java）基于GUI的计算器的算法

2 个答案: