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

在我跳入我的问题之前我想说明的是，实际上我并不主要需要编程帮助，我刚才一直在想这个问题好几天，所以也许这是不完全是一个基于编程的问题。（Java）基于GUI的计算器的算法

经过大约2年的编程缺席之后，我决定在前几天提高我的知识水平。我为一个计算器编写了一个基于swing的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; } 
}

那么，再次检查程序时，我发现，单个数字的这个算法既不能正常工作，但我的问题仍然是一样的。我也会对一些意见或想法感到高兴，以使它更容易，更流畅或以更好的方式。

来源

2017-10-18 ednhzrd

至于多位数字：如果您在启动程序时设置当前号码为空字符串或输入操作，然后点击一个数字按钮时应该只是成为将所选择的数字为当前数量的问题（添加另外的数字后，这是一个字符串，直到你需要它进行计算）。 – Thomas

顺便说一下，我会说你发布的代码对于SO来说有点太多了，而且它的大部分内容都与这个问题无关。关于要发布什么样的代码，请在[ask]和[mcve]上有一个掠夺。 – Thomas

另请参阅此[计算器示例]（http://stackoverflow.com/a/7441804/418556）。它使用'ScriptEngine'来评估文本字段中的表达式。 –

另一个建议：如果可能更容易创建一个分析和评估字符串的计算器。在这个on the net上有很多例子，所以这应该是一个有趣而又不太困难的任务，尤其是因为你正在努力提高你的编程技能（你甚至可以实现并提供几个解析器来玩）。

然后，用户界面将具有创建字符串的简单任务，即每个按钮只是将一个字符添加到当前方程字符串，然后按钮将运行解析器。

来源

2017-10-18 12:17:10 Thomas

嗯，这是我寻找的解决方案，但如果你不知道如何谷歌，这是不容易找到。感谢无论如何，我可能会用这种方法:) – ednhzrd

@ednhzrd是的，有一个很好的搜索词有时很难。祝你好运，尤其是在你的学习努力中。 :) – Thomas

对于多位数字，您应该使用一个字符串，以便当用户单击某个数字时，该数字被附加到字符串。使用JTextField，您可以将打字和点击数字按钮组合在一起。

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

在更先进的水平，可以为括号添加按钮。在输入/退出圆括号时，您可以使用一堆以前的数字来推送和弹出它们。

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

来源

2017-10-18 13:18:22 jurez

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

回答

相关问题