java中的计算器程序
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/16198401/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Calculator program in java
提问by user1959360
I am a beginner in java and I have written this code with the help of an online available program. The code attached is a part of the code which performs action when buttons of the calculator are pressed.In the CalculatorDemo class i have initialized all the buttons(b0-b24) and the TextField tf. In this class I am using char OP as a flag ,so that, when I press '+' the OP is assigned '+' and I have even checked it on command prompt. But when i press '=' ,the OP is automatically assigned '\0' and i don't know how and why. And hence, no operation is performed at all. And I don't understand where the logic is wrong. Please help
我是 Java 的初学者，我在一个在线可用程序的帮助下编写了这段代码。附加的代码是按下计算器按钮时执行操作的代码的一部分。在 CalculatorDemo 类中，我已经初始化了所有按钮（b0-b24）和 TextField tf. 在这门课中，我使用 char OP 作为标志，因此，当我按“+”时，OP 被分配了“+”，我什至在命令提示符下检查了它。但是当我按 '=' 时，OP 会自动分配 '\0' 并且我不知道如何以及为什么。因此，根本不执行任何操作。我不明白逻辑哪里错了。请帮忙
import java.awt.event.*;
import java.awt.*;
class CalculatorActionperform implements ActionListener
{
CalculatorDemo temp;
public boolean foundKey;
String command;
String s="", s1,s2,s3,s4,s5,s6;
int n;
char OP;
CalculatorActionperform(CalculatorDemo d)
{
temp=d;
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==temp.b23)
{
s3=temp.tf.getText();
s4="0";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b22)
{
s3=temp.tf.getText();
s4="1";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b21)
{
s3=temp.tf.getText();
s4="2";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b20)
{
s3=temp.tf.getText();
s4="3";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b15)
{
s3=temp.tf.getText();
s4="4";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b16)
{
s3=temp.tf.getText();
s4="5";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b17)
{
s3=temp.tf.getText();
s4="6";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b12)
{
s3=temp.tf.getText();
s4="7";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b11)
{
s3=temp.tf.getText();
s4="8";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b10)
{
s3=temp.tf.getText();
s4="9";
s5=s3+s4;
temp.tf.setText(s5);
}
if(e.getSource()==temp.b14)
{
s1=temp.tf.getText();
temp.tf.setText("");
OP='+';
}
if(e.getSource()==temp.b19)
{
s1=temp.tf.getText();
temp.tf.setText("");
OP='-';
}
if(e.getSource()==temp.b18)
{
s1=temp.tf.getText();
temp.tf.setText("");
OP='*';
}
if(e.getSource()==temp.b13)
{
s1=temp.tf.getText();
temp.tf.setText("");
OP='/';
}
if(e.getSource()==temp.b9) /* b9= '=' */
{
s2=temp.tf.getText();
if(OP=='public class Calculator {
private JFrame window;
private List<JButton> keypad;
private JLabel display;
private int result;
private StringBuffer digitsEntered;
private int integerEntered;
}
')
{
System.out.println("null");
}
if(OP=='+')
{
n=Integer.parseInt(s1)+Integer.parseInt(s2);
temp.tf.setText(String.valueOf(n));
}
else
if(OP=='-')
{
n=Integer.parseInt(s1)-Integer.parseInt(s2);
temp.tf.setText(String.valueOf(n));
}
else
if(OP=='*')
{
n=Integer.parseInt(s1)*Integer.parseInt(s2);
temp.tf.setText(String.valueOf(n));
}
else
if(OP=='/')
{
n=Integer.parseInt(s1)/Integer.parseInt(s2);
temp.tf.setText(String.valueOf(n));
}
}
if(e.getSource()==temp.b6)
{
temp.tf.setText("");
}
}
}
回答by Mike Tunnicliffe
I'm not going to go into the code you have posted in your questions, but rather attempt to help you attack your overall goal of writing a calculator demo.
我不会深入研究您在问题中发布的代码，而是试图帮助您实现编写计算器演示的总体目标。
The first step should be to get a clear idea of the problem by writing it down:
第一步应该是通过写下问题来清楚地了解问题：
I need a calculator with a display and a keypad with the digits 0-9 and the operators +,-,x,/ and an = button. The calculator should read a series digits from the keypad, then a mathematical operator, then another series of digits and so on. Each uninterrupted series of digits should be converted into an integer value.
The calculator should calculate the result of applying the mathematical operator to the first and second integer values. If further operators and integers are entered, the mathematical operator should be applied to the result of the prior calculation and the further integer. This process should continue until the equals button is pressed. When digits are pressed on the keypad they should appear in the text display appended to those digits entered so far.
When an operator or the equals button is pressed this signals the end of the entry of an integer, if this completes a calculation then the result should be shown on the display, otherwise the integer should remain in the display until another digit is pressed - then the display should be cleared and the new digit displayed, and subsequent digits appended, as before.
我需要一个带显示器的计算器和一个带有数字 0-9 和运算符 +、-、x、/ 和 = 按钮的小键盘。计算器应该从键盘读取一系列数字，然后是数学运算符，然后是另一系列数字，依此类推。每个不间断的数字序列都应转换为整数值。
计算器应计算将数学运算符应用于第一个和第二个整数值的结果。如果输入了更多的运算符和整数，则数学运算符应应用于先前计算的结果和更多的整数。这个过程应该一直持续到按下等于按钮。当在键盘上按下数字时，它们应该出现在附加到目前输入的数字的文本显示中。
当按下运算符或等于按钮时，这表示整数输入结束，如果计算完成，则结果应显示在显示屏上，否则整数应保留在显示屏中，直到按下另一个数字 - 然后应清除显示并显示新数字，并像以前一样附加后续数字。
From this description we can identify some nouns: Calculator, Button, Display, Keypad, Digit, Operator, Integer, Result ...and some verbs: Read, Press, Convert, Calculate, Apply, Enter, Complete, Show, Remain, Clear, Display, Append
从这个描述中，我们可以识别一些名词：计算器、按钮、显示、键盘、数字、运算符、整数、结果......和一些动词：阅读、按下、转换、计算、应用、输入、完成、显示、保留、清除, 显示, 追加
These give us an idea of the state and behaviour required for our program. We then decide how to model these in our implementation. Typically nouns can be modelled as classes/instance variables (state) and verbs as methods (behaviour).
这些让我们了解程序所需的状态和行为。然后我们决定如何在我们的实现中对这些进行建模。通常，名词可以建模为类/实例变量（状态），动词可以建模为方法（行为）。
Here is one possible design:
这是一种可能的设计：
A class called Calculator using Swing components to represent the Buttons/Keypad and Display; using the primitive int type for representing Integer/Result/Digit; using Java mathematical operators for representing Operator.
一个名为 Calculator 的类，使用 Swing 组件来表示按钮/键盘和显示；使用原始 int 类型来表示整数/结果/数字；使用 Java 数学运算符来表示运算符。
Let's start to make the bones of this:
让我们开始制作这个骨架：
public class Calculator implements ActionListener {
private JFrame window;
private List<JButton> keypad;
private JLabel display;
private int result;
private StringBuffer digitsEntered;
private int integerEntered;
public Calculator() {
JButton zeroButton = new JButton("0");
zeroButton.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
// this would get executed when zeroButton is pressed
}
}
Now we need to work out how we are going to Read/Press buttons. We will need to set up our JButtons to respond to being activated and wire up that event to a method we define in our Calculator class.
现在我们需要弄清楚我们将如何阅读/按下按钮。我们需要设置我们的JButtons 以响应被激活并将该事件连接到我们在 Calculator 类中定义的方法。
One way to do this is to create the JButtons and add a listener to them. We can make Calculatorimplement the ActionListenerinterface, which forces it to define a method actionPerformedwith a single ActionEventargument. We can see how this would work by creating a JButtonin Calculator's constructor.
一种方法是创建JButtons 并向它们添加侦听器。我们可以Calculator实现ActionListener接口，强制它定义一个actionPerformed带有单个ActionEvent参数的方法。我们可以通过创建JButtoninCalculator的构造函数来了解这是如何工作的。
public class Calculator implements ActionListener {
private JFrame window;
private List<JButton> keypad;
private JLabel display;
private int result;
private StringBuffer digitsEntered;
private int integerEntered;
public Calculator() {
window = new JFrame("Calculator");
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton zeroButton = new JButton("0");
zeroButton.addActionListener(this);
window.add(zeroButton, BorderLayout.CENTER);
window.pack();
window.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
// this would get executed when zeroButton is pressed
JOptionPane.showMessageDialog(window, "Button pressed");
}
public static void main(String[] args) {
new Calculator();
}
}
Note this code won't do anything yetbecause we haven't set up the window and connected the button to it. However, the code should illustrate how we can run code from a button press.
注意这段代码不会做任何事情，因为我们还没有设置窗口并将按钮连接到它。但是，代码应该说明我们如何通过按下按钮来运行代码。
Let's get on and get this code in a working state by setting everything up:
让我们继续并通过设置所有内容使此代码处于工作状态：
for (int digit = 0; digit <=9; digit++) {
JButton button = new JButton(Integer.toString(digit));
button.addActionListener(this);
window.add(button);
}
OK, we need more than one button, we need a whole load. Let's make digits 0-9:
好的，我们需要不止一个按钮，我们需要一整套。让我们制作数字 0-9：
public Calculator() {
window = new JFrame("Calculator");
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel digitsPanel = new JPanel();
digitsPanel.setLayout(new GridLayout(4, 3));
for (int digit = 0; digit <=9; digit++) {
JButton button = new JButton(Integer.toString(digit));
button.addActionListener(this);
digitsPanel.add(button);
}
window.add(digitsPanel);
window.pack();
window.setVisible(true);
}
Hmm that didn't work right- only one button appears on the window. That's because we have the default window layout which isn't what we need. We want the buttons to appear in a grid, grouped together in the window. Let's create a JPanelto group the buttons together in and use a GridLayoutfor the panel, then we can add the panel to the window.
嗯，这不起作用- 窗口上只出现一个按钮。那是因为我们有默认的窗口布局，这不是我们需要的。我们希望按钮出现在一个网格中，在窗口中组合在一起。让我们创建 aJPanel将按钮组合在一起并使用 aGridLayout作为面板，然后我们可以将面板添加到窗口中。
public Calculator() {
window = new JFrame("Calculator");
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.setLayout(new BorderLayout());
JPanel digitsPanel = new JPanel();
digitsPanel.setLayout(new GridLayout(4, 3));
int[] digitOrder = new int[] { 7,8,9,4,5,6,1,2,3,0 };
for (int digit : digitOrder) {
JButton button = new JButton(Integer.toString(digit));
button.addActionListener(this);
digitsPanel.add(button);
}
window.add(digitsPanel, BorderLayout.CENTER);
JPanel operatorsPanel = new JPanel();
operatorsPanel.setLayout(new GridLayout(5,1));
String[] operators = new String[] { "+","-","x","/","=" };
for (String operator : operators) {
JButton button = new JButton(operator);
button.addActionListener(this);
operatorsPanel.add(button);
}
window.add(operatorsPanel, BorderLayout.EAST);
window.pack();
window.setVisible(true);
}
That's not bad, but the numbers don't come up in the usual order you'd see on a numpad. That's because they appear in the order added from top-left to bottom-right. We can fix that by specifying the order we want with an array, and iterate through that (we use the for-eachstyle iterator for this because it's neater). While we're doing that, we can do something similar for the mathematical operators and equals button and add them to the frame too (here we'll be explicit about the layout to use for the window and we'll use a BorderLayout).
这还不错，但是数字不会按照您在数字键盘上看到的通常顺序出现。那是因为它们按从左上角到右下角的添加顺序出现。我们可以通过用数组指定我们想要的顺序来解决这个问题，并遍历它（我们为此使用for-each样式迭代器，因为它更整洁）。当我们这样做时，我们可以对数学运算符和等于按钮做类似的事情，并将它们也添加到框架中（这里我们将明确用于窗口的布局，我们将使用BorderLayout）。
...
private JLabel display;
...
public Calculator() {
window = new JFrame("Calculator");
...
display = new JLabel();
display.setHorizontalAlignment(JLabel.RIGHT);
display.setText("0");
window.add(display, BorderLayout.NORTH);
...
window.pack();
window.setVisible(true);
}
OK, we're nearly done with the components. We just need to add a display.
好的，我们几乎完成了组件。我们只需要添加一个显示器。
StringBuffer digitsEntered;
...
public Calculator() {
...
digitsEntered = new StringBuffer();
...
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() instanceof JButton) {
String buttonText = ((JButton)e.getSource()).getText();
if (Character.isDigit(buttonText.charAt(0))) {
digitsEntered.append(buttonText.charAt(0));
display.setText(digitsEntered.toString());
}
}
}
Now we just need to implement the logicto respond to button presses. First, let's see what we need to do if a digit is pressed. We need to deal with the Append and Show verbs and append that digit to our input and display it.
现在我们只需要实现响应按钮按下的逻辑。首先，让我们看看如果按下一个数字，我们需要做什么。我们需要处理 Append 和 Show 动词并将该数字附加到我们的输入并显示它。
private String currentOperator;
...
public void actionPerformed(ActionEvent e) {
if (e.getSource() instanceof JButton) {
String buttonText = ((JButton)e.getSource()).getText();
if (Character.isDigit(buttonText.charAt(0))) {
digitsEntered.append(buttonText.charAt(0));
display.setText(digitsEntered.toString());
} else {
integerEntered = Integer.parseInt(digitsEntered.toString());
digitsEntered.setLength(0); // clear out the input so a new integer can be entered
currentOperator = buttonText; // remember the operator
}
}
}
Cool. Now we need to implement the Convert verb and convert our digits into an integer. This will happen when an operator or equals is pressed. We need to remember what operator was pressed so we know what calculation to do when the second integer is entered.
凉爽的。现在我们需要实现转换动词并将我们的数字转换为整数。当按下运算符或等于时会发生这种情况。我们需要记住按下的是哪个运算符，以便我们知道在输入第二个整数时要进行什么计算。
...
} else {
if (currentOperator == null) {
integerEntered = Integer.parseInt(digitsEntered.toString());
} else {
int previousInteger = integerEntered;
integerEntered = Integer.parseInt(digitsEntered.toString());
if ("+".equals(currentOperator)) {
result = previousInteger + integerEntered;
display.setText(Integer.toString(result));
}
}
digitsEntered.setLength(0); // clear out the input so a new integer can be entered
currentOperator = buttonText; // remember the operator
}
...
Now we actually need to handle the second time an operator or equals is pressed, when we already have an integer and operator saved away. Here we can implement the + part of the Calculate/Apply verb and Show the result.
现在我们实际上需要处理第二次按下运算符或等于时，当我们已经保存了一个整数和运算符时。在这里，我们可以实现计算/应用动词的 + 部分并显示结果。
...
integerEntered = Integer.parseInt(digitsEntered.toString());
if (currentOperator == null) {
result = integerEntered;
} else {
if ("+".equals(currentOperator)) {
result = result + integerEntered;
display.setText(Integer.toString(result));
}
}
...
This isn't quite right. It will put into result the sum of the previous 2 integers rather than the sum of all integers entered so far. We need to store the first value in resultthen add each subsequent integer to the value stored in result. This means we don't need the previousIntegervariable any more, and we have some duplicate code in both the ifand elsethat we can just execute before the if.
这不太对。它将把前 2 个整数的总和放入结果中，而不是到目前为止输入的所有整数的总和。我们需要将第一个值存储在 中，result然后将每个后续整数与存储在 中的值相加result。这意味着我们不需要previousInteger变量更多，我们有一些重复的代码，同时在if和else我们能在之前刚刚执行if。
...
integerEntered = Integer.parseInt(digitsEntered.toString());
if (currentOperator == null) {
result = integerEntered;
} else {
if ("+".equals(currentOperator)) {
result = result + integerEntered;
} else if ("-".equals(currentOperator)) {
result = result - integerEntered;
} else if ("x".equals(currentOperator)) {
result = result * integerEntered;
} else if ("/".equals(currentOperator)) {
result = result / integerEntered;
} else if ("=".equals(currentOperator)) {
result = integerEntered;
} else {
// Unrecognised operator
}
display.setText(Integer.toString(result));
}
...
Let's implement the other operators.
让我们实现其他运算符。
...
if (digitsEntered.length() > 0) {
integerEntered = Integer.parseInt(digitsEntered.toString());
if (currentOperator == null) {
result = integerEntered;
} else {
if ("+".equals(currentOperator)) {
result = result + integerEntered;
} else if ("-".equals(currentOperator)) {
result = result - integerEntered;
} else if ("x".equals(currentOperator)) {
result = result * integerEntered;
} else if ("/".equals(currentOperator)) {
result = result / integerEntered;
} else if ("=".equals(currentOperator)) {
result = integerEntered;
} else {
// Unrecognised operator
}
display.setText(Integer.toString(result));
}
}
...
Here we make = an operator that acts like a reset and allow us to start a new calculation. You may notice you get an error if you try to hit = then + (to add a number to the result); this is because there are no digits in the input to convert to an integer for the + operator. We can solve this by skipping the calculation in this case.
在这里，我们 make = 一个操作符，其作用类似于重置并允许我们开始新的计算。您可能会注意到，如果您尝试按 = then +（向结果中添加一个数字），则会出现错误；这是因为输入中没有数字可以转换为 + 运算符的整数。在这种情况下，我们可以通过跳过计算来解决这个问题。
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
public class Calculator implements ActionListener {
private JFrame window;
private List<JButton> keypad;
private JLabel display;
private int result;
private StringBuffer digitsEntered;
private int integerEntered;
private String currentOperator;
public Calculator() {
window = new JFrame();
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.setLayout(new BorderLayout());
digitsEntered = new StringBuffer();
display = new JLabel();
display.setHorizontalAlignment(JLabel.RIGHT);
display.setText("0");
window.add(display, BorderLayout.NORTH);
JPanel digitsPanel = new JPanel();
digitsPanel.setLayout(new GridLayout(4, 3));
int[] digitOrder = new int[] { 7,8,9,4,5,6,1,2,3,0 };
for (int digit : digitOrder) {
JButton button = new JButton(Integer.toString(digit));
button.addActionListener(this);
digitsPanel.add(button);
}
window.add(digitsPanel, BorderLayout.CENTER);
JPanel operatorsPanel = new JPanel();
operatorsPanel.setLayout(new GridLayout(5,1));
String[] operators = new String[] { "+","-","x","/","=" };
for (String operator : operators) {
JButton button = new JButton(operator);
button.addActionListener(this);
operatorsPanel.add(button);
}
window.add(operatorsPanel, BorderLayout.EAST);
window.pack();
window.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() instanceof JButton) {
String buttonText = ((JButton)e.getSource()).getText();
if (Character.isDigit(buttonText.charAt(0))) {
digitsEntered.append(buttonText.charAt(0));
display.setText(digitsEntered.toString());
} else {
if (digitsEntered.length() > 0) {
integerEntered = Integer.parseInt(digitsEntered.toString());
if (currentOperator == null) {
result = integerEntered;
} else {
if ("+".equals(currentOperator)) {
result = result + integerEntered;
} else if ("-".equals(currentOperator)) {
result = result - integerEntered;
} else if ("x".equals(currentOperator)) {
result = result * integerEntered;
} else if ("/".equals(currentOperator)) {
result = result / integerEntered;
} else if ("=".equals(currentOperator)) {
result = integerEntered;
} else {
// Unrecognised operator
}
display.setText(Integer.toString(result));
}
}
digitsEntered.setLength(0); // clear out the input so a new integer can be entered
currentOperator = buttonText; // remember the operator
}
}
}
public static void main(String[] args) {
new Calculator();
}
}
Here is the full code so far. It doesn't handle divide by 0, keypadis never used and can be removed, and integerEnteredreally need only be a local variable and not a instance variable. However, the code should mostly work, let me know if you spot any problems. I also have a cleaner version (the first implementation I did) but it wasn't so simple to explain.
这是到目前为止的完整代码。它不处理除以 0，keypad从不使用并且可以删除，并且integerEntered实际上只需要是局部变量而不是实例变量。但是，代码应该可以正常工作，如果您发现任何问题，请告诉我。我也有一个更干净的版本（我做的第一个实现），但解释起来并不那么简单。
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.border.EmptyBorder;
public class CalculatorDemo extends JFrame {
private static final long serialVersionUID = 1L;
private StringBuffer inputBuffer = new StringBuffer();
private String queuedOperator = null;
private int leftHandSide = 0;
private JLabel inputDisplay;
private JLabel operatorIndicator;
private class DigitButtonAction extends AbstractAction {
private static final long serialVersionUID = 1L;
private final int digit;
public DigitButtonAction(final int digit) {
super(Integer.toString(digit));
this.digit = digit;
}
@Override
public void actionPerformed(ActionEvent e) {
enterDigit(digit);
}
}
private class OperatorButtonAction extends AbstractAction {
private static final long serialVersionUID = 1L;
private final String operator;
public OperatorButtonAction(final String operator) {
super(operator);
this.operator = operator;
}
@Override
public void actionPerformed(ActionEvent e) {
performOperation(operator);
}
}
public CalculatorDemo() {
super("Calculator");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
setSize(100, 200);
// Create display text field
inputDisplay = new JLabel();
inputDisplay.setHorizontalAlignment(JLabel.RIGHT);
inputDisplay.setText(Integer.toString(leftHandSide));
operatorIndicator = new JLabel();
operatorIndicator.setBorder(new EmptyBorder(0, 4, 0, 4));
final JPanel display = new JPanel();
display.setLayout(new BorderLayout());
display.add(inputDisplay, BorderLayout.CENTER);
display.add(operatorIndicator, BorderLayout.WEST);
// Create number buttons
final JPanel digitPanel = new JPanel();
digitPanel.setLayout(new GridLayout(4,3));
final int[] digitKeyOrder = new int[] { 7,8,9,4,5,6,1,2,3 };
for (int digit : digitKeyOrder) {
digitPanel.add(new JButton(new DigitButtonAction(digit)));
}
digitPanel.add(new JPanel()); // Blank spacer panel
digitPanel.add(new JButton(new DigitButtonAction(0)));
// Create operators
final String[] OPERATORS = { "+","-","*","/","=" };
final JPanel operatorPanel = new JPanel();
operatorPanel.setLayout(new GridLayout(OPERATORS.length, 1));
for (String op : OPERATORS) {
operatorPanel.add(new JButton(new OperatorButtonAction(op)));
}
add(digitPanel, BorderLayout.CENTER);
add(operatorPanel, BorderLayout.EAST);
add(display, BorderLayout.NORTH);
pack();
}
private void enterDigit(final int digit) {
if (digit == 0 && inputBuffer.length() == 0) return;
inputBuffer.append(Integer.toString(digit));
inputDisplay.setText(inputBuffer.toString());
}
private int calculate(final int leftHandSide, final String operator, final int rightHandSide) {
if (operator == null) return rightHandSide;
else if ("+".equals(operator)) return leftHandSide + rightHandSide;
else if ("-".equals(operator)) return leftHandSide - rightHandSide;
else if ("*".equals(operator)) return leftHandSide * rightHandSide;
else if ("/".equals(operator)) return leftHandSide / rightHandSide;
else if ("=".equals(operator)) return rightHandSide;
else {
throw new IllegalStateException("Unrecognised operator " + operator);
}
}
private void performOperation(final String operator) {
try {
final int rightHandSide = Integer.parseInt(inputBuffer.toString());
leftHandSide = calculate(leftHandSide, queuedOperator, rightHandSide);
} catch (NumberFormatException e) {
// Ignore failure to parse inputBuffer to integer
// calculate() not called, just carry on and clear the
// inputBuffer and queue a new operator
} catch (ArithmeticException e) {
// Divide by 0 in calculate()
operatorIndicator.setText("");
inputDisplay.setText(e.getMessage());
queuedOperator = null;
return;
} catch (IllegalStateException e) {
// Unrecognised operator
operatorIndicator.setText("");
inputDisplay.setText(e.getMessage());
queuedOperator = null;
return;
}
inputBuffer.setLength(0); // Clear inputBuffer
queuedOperator = operator; // Queue next operator
// Update display
operatorIndicator.setText(queuedOperator);
inputDisplay.setText(Integer.toString(leftHandSide));
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new CalculatorDemo().setVisible(true);
}
});
}
}
Here's the cleaner, but more complicated version:
这是更干净但更复杂的版本：
class InvalidNum2 extends Exception
{
InvalidNum2()
{
super("Invalid Num:num2 cannot be zero");
}
}
class Calculator
{
static int div(int n,int m) throws InvalidNum2
{
if(m==0)
{
throw new InvalidNum2();
}
else
{
return(n/m);
}
}
public static void main(String args[])
{
int num1,num2;
int a,b,c,d;
num1=Integer.parseInt(args[0]);
num2=Integer.parseInt(args[2]);
char op=args[1].charAt(0);
if(args.length!=3)
{
System.out.println("incorrect no. of argument");
System.exit(0);
}
else
{
try
{
switch(op)
{
case '+' :
a=num1+num2;
System.out.println("additiom:"+a);
break;
case '-' :
b=num1-num2;
System.out.println("Sub:"+b);
break;
case '*' :
c=num1*num2;
System.out.println("mul:"+c);
break;
case '/' :
d=div(num1,num2);
System.out.println("div:"+d);
break;
default :
{ System.out.println("wrong ch");}
}
}catch(Exception E){
System.out.println(E);}
}
}
}
回答by Bhumi Patel
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class calculatatorApp extends Applet implements ActionListener {
Button b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,ad,sub,mul,div,mo,eq,c;
TextField t1;
static int a=0,b=0,res=0;
public calculatatorApp()
{
Panel p1=new Panel();
Panel p2=new Panel();
t1=new TextField(10);
b0=new Button("0");
b1=new Button("1");
b2=new Button("2");
b3=new Button("3");
b4=new Button("4");
b5=new Button("5");
b6=new Button("6");
b7=new Button("7");
b8=new Button("8");
b9=new Button("9");
ad=new Button("+");
sub=new Button("-");
mul=new Button("*");
div=new Button("/");
mo=new Button("%");
eq=new Button("=");
c=new Button("c");
c.addActionListener(this);
b0.addActionListener(this);
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
b5.addActionListener(this);
b6.addActionListener(this);
b7.addActionListener(this);
b8.addActionListener(this);
b9.addActionListener(this);
ad.addActionListener(this);
sub.addActionListener(this);
mul.addActionListener(this);
div.addActionListener(this);
mo.addActionListener(this);
eq.addActionListener(this);
p1.add(t1);
p2.add(b1);
p2.add(b2);
p2.add(b3);
p2.add(ad);
p2.add(b4);
p2.add(b5);
p2.add(b6);
p2.add(sub);
p2.add(b7);
p2.add(b8);
p2.add(b9);
p2.add(mul);
p2.add(b0);
p2.add(c);
p2.add(eq);
p2.add(mo);
p2.add(div);
}
@Override
public void actionPerformed(ActionEvent ae) {
// TODO Auto-generated method stub
String str=ae.getActionCommand();
if(str.equals("0"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("1"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("2"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("3"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("4"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("5"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("6"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("7"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("8"))
{
t1.setText(t1.getText()+""+str);
}
if(str.equals("9"))
{
t1.setText(t1.getText()+""+str);
}
if(t1.getText().equals("0"))
{
t1.setText("");
}
if(str.equals("+")|| str.equals("-")||str.equals("*")||str.equals("/")||str.equals("%") )
{
a=Integer.parseInt(t1.getText());
t1.setText("");
}
if(str.equals("=")){
b=Integer.parseInt(t1.getText());
res=a+b;
t1.setText(""+res);
res=a-b;
t1.setText(""+res);
res=a*b;
t1.setText(""+res);
res=a/b;
t1.setText(""+res);
res=a%b;
t1.setText(""+res);
}
}
}
回答by Bhumi Patel
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Math. = new Maths();
double answer = 0;
double inputA, inputB;
char operator;
boolean done = false;
while (done == false) {
System.out.print("Please enter your sum: ");
inputA = input.nextDouble();
operator = input.next().charAt(0);
inputB = input.nextDouble();
switch (operator) {
case '+': answer = Math.add(inputA, inputB);
break;
case '-': answer = Math.subtract(inputA, inputB);
break;
case '*': answer = Math.multiply(inputA, inputB);
break;
case '/': answer = Math.divide(inputA, inputB);
break;
case '^': answer = Math.power(inputA, inputB);
break;
}
System.out.println(answer);
}
input.close();
}
}
