Question

我是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=='\0')
                {
                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("");
                }
        }
    }

Answer 1

我不打算进入您在问题中发布的代码，而是尝试帮助您攻击编写计算器演示的总体目标。

第一步应该是通过写下来清楚地了解问题：

我需要一个带显示屏和键盘的计算器，数字0-9和操作符+， - ，x，/和an =按钮。计算器应该从键盘读取一系列数字，然后是数学运算符，然后是另一系列数字，依此类推。应将每个不间断的数字系列转换为整数值。

计算器应计算将数学运算符应用于第一个和第二个整数值的结果。如果输入了其他运算符和整数，则应将数学运算符应用于先前计算的结果和更多整数。此过程应继续，直到按下等于按钮。当在键盘上按下数字时，它们应出现在到目前为止输入的数字附加的文本显示中。

当按下操作符或等于按钮时，这表示整数输入结束，如果完成计算，则结果应显示在显示屏上，否则整数应保留在显示中，直到另一位数为按下 - 然后应清除显示并显示新数字，并附加后续数字，如前所述。

从这个描述我们可以识别一些名词：计算器，按钮，显示，键盘，数字，运算符，整数，结果 ...和一些动词：阅读，按，转换，计算，应用，回车，完成，显示，保留，清除，显示，追加

这些让我们了解了我们计划所需的状态和行为。然后我们决定如何在实现中对这些进行建模。通常，名词可以被建模为类/实例变量（状态），动词可以被建模为方法（行为）。

这是一种可能的设计：

一个名为Calculator的类，使用Swing组件来表示Buttons / Keypad和Display;使用原始int类型表示Integer / Result / Digit;使用Java数学运算符表示运算符。

让我们开始研究这个：

public class Calculator {
    private JFrame window;
    private List<JButton> keypad;
    private JLabel display;
    private int result;
    private StringBuffer digitsEntered;
    private int integerEntered;
}

现在我们需要弄清楚我们将如何阅读/按下按钮。我们需要设置JButton来响应激活并将该事件连接到我们在Calculator类中定义的方法。

执行此操作的一种方法是创建JButton并为其添加侦听器。我们可以使Calculator实现ActionListener接口，这会强制它使用单个actionPerformed参数定义方法ActionEvent。我们可以通过在JButton的构造函数中创建Calculator来了解这是如何工作的。

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
    }
}

请注意，此代码尚未执行任何操作，因为我们尚未设置窗口并将按钮连接到该窗口。但是，代码应该说明我们如何从按下按钮运行代码。

让我们通过设置所有内容来使代码处于工作状态：

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();
    }
}

好的，我们需要一个以上的按钮，我们需要一个完整的负载。让我们做数字0-9：

for (int digit = 0; digit <=9; digit++) {
    JButton button = new JButton(Integer.toString(digit));
    button.addActionListener(this);
    window.add(button);
}

嗯，没有正常工作 - 窗口上只显示一个按钮。这是因为我们的默认窗口布局并不是我们所需要的。我们希望按钮显示在网格中，在窗口中组合在一起。让我们创建一个JPanel将按钮组合在一起，然后使用面板的GridLayout，然后我们就可以将面板添加到窗口中。

    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);
    }

那不错，但这些数字并没有按照你在小键盘上看到的通常顺序出现。这是因为它们出现在从左上角到右下角添加的顺序中。我们可以通过使用数组指定我们想要的顺序来解决这个问题，然后对其进行迭代（我们使用 for-each 样式迭代器，因为它更整洁）。虽然我们正在这样做，但我们可以为数学运算符和等号按钮做类似的事情，并将它们添加到框架中（这里我们将明确说明用于窗口的布局，我们＆＃39; ll使用BorderLayout）。

    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);
    }

好的，我们几乎完成了组件。我们只需要添加一个显示器。

    ...
    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);
    }

现在我们只需要实现逻辑来响应按钮按下。首先，让我们看看如果按下数字我们需要做什么。我们需要处理Append和Show动词，并将该数字附加到我们的输入并显示它。

    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());
            }
        }
    }

冷却。现在我们需要实现Convert动词并将我们的数字转换为整数。当按下操作符或等号时会发生这种情况。我们需要记住按下了什么操作符，这样我们就知道在输入第二个整数时要做什么计算。

    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
            }
        }
    }

现在我们实际上需要在第二次处理操作符或等号时处理，当我们已经有一个整数并且运算符被保存时。在这里，我们可以实现Calculate / Apply动词的+部分并显示结果。

            ...
            } 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
            }
            ...

这不是很正确。它将结果是前两个整数的总和而不是到目前为止输入的所有整数的总和。我们需要将第一个值存储在result中，然后将每个后续整数添加到result中存储的值中。这意味着我们不再需要previousInteger变量，我们在if和else中都有一些重复的代码，我们可以在if之前执行}。

                ...
                integerEntered = Integer.parseInt(digitsEntered.toString());
                if (currentOperator == null) {
                    result = integerEntered;
                } else {
                    if ("+".equals(currentOperator)) {
                        result = result + integerEntered;
                        display.setText(Integer.toString(result));
                    }
                }
                ...

让我们实现其他运营商。

                ...
                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));
                }
                ...

这里我们使=运算符像重置一样，允许我们开始一个新的计算。如果您尝试按=然后+（为结果添加数字），您可能会注意到您收到错误;这是因为输入中没有数字可以转换为+运算符的整数。我们可以通过跳过这种情况下的计算来解决这个问题。

                ...
                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));
                    }
                }
                ...

到目前为止，这是完整的代码。它不会处理除以0，keypad从未使用过并且可以删除，而integerEntered实际上只需要是局部变量而不是实例变量。但是，代码应该主要起作用，如果发现任何问题，请告诉我。我也有一个更干净的版本（我做的第一个实现），但解释起来并不那么简单。

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();
    }
}

这里是更清洁但更复杂的版本：

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);
            }
        });
    }
}

Answer 2

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);}
        }

    }
}

Answer 3

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);


                        }



                }
}

Answer 4

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();

  }

}

java中的计算器程序

4 个答案: