java中的计算器程序

我是java的初学者，我在一个在线可用程序的帮助下编写了这段代码。所附代码是当按下计算器按钮时执行操作的代码的一部分。在CalculatorDemo类中，我初始化了所有按钮（b0-b24）和文本字段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("");
                }
        }
    }

---

我不打算讨论您在问题中发布的代码，而是试图帮助您实现编写计算器演示的总体目标

第一步应该是把问题写下来，对问题有一个清晰的认识：

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

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、运算符+、-、x/和=按钮的键盘。计算器应从键盘上读取一系列数字，然后是数学运算符，然后是另一系列数字，依此类推。每个不间断的数字序列应转换为整数值

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

当按下运算符或等于按钮时，这表示整数输入结束，如果这完成了计算，则结果应显示在显示屏上，否则整数应保留在显示屏上，直到按下另一个数字-然后应清除显示屏并显示新的数字，和前面一样，添加后面的数字

从这个描述中，我们可以识别一些名词：计算器、按钮、显示器、键盘、数字、运算符、整数、结果 …还有一些动词：读、按、转换、计算、应用、输入、完成、显示、保留、清除、显示、附加

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

以下是一种可能的设计：

一个名为Calculator的类，使用Swing组件表示按钮/键盘和显示器；使用原语int类型表示整数/结果/数字；使用Java数学运算符表示运算符

让我们开始做这方面的重点：

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

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

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

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

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

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

这还不错，但数字的排列顺序与你在numpad上看到的不一样。这是因为它们按从左上到右下的顺序显示。我们可以通过指定数组的顺序来修复这个问题，并对其进行迭代（我们使用for-each样式迭代器，因为它更简洁）。在这样做的同时，我们可以对“数学运算符”和“等于”按钮执行类似的操作，并将它们添加到框架中（这里我们将明确说明窗口使用的布局，并使用

边框布局
）

好的，我们的组件差不多完成了。我们只需要添加一个显示

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

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

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

现在我们实际上需要处理第二次按下运算符或equals，当我们已经保存了一个整数和运算符时。在这里，我们可以实现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));
                }
                ...

这里，我们使用make=一个类似于重置的操作符，允许我们开始新的计算。如果您尝试点击=然后+（在结果中添加一个数字），您可能会注意到出现错误；这是因为输入中没有数字可转换为+运算符的整数。在这种情况下，我们可以通过跳过计算来解决这个问题

                ...
                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除的情况，
键盘
从未使用过，可以删除，
整数
实际上只需要是一个局部变量，而不是一个实例变量。然而，代码应该大部分工作，让我知道如果你发现任何问题。我也有一个更干净的版本（我做的第一个实现），但解释起来并不简单

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

我建议您首先重构代码。将temp重命名为abetter变量。放不同的b1。
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);
            }
        });
    }
}

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

    }
}

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


                        }



                }
}                   

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

  }

}