学习笔记——简易练习：使用Java AWT实现一个简单的计算器

AWT 计算器

前言

因为想写一个有界面的超市商品信息管理系统，所以最近在复习java的GUI，正好做个简单的小项目练练手

设计思路

首先一个计算器需要有输入框和按键，先进行一个简单的布局，一个窗体，用表格布局将窗体分为两行一列，上面那行插入一个文本输入框，下面的那行插入三个面板，在面板中插入需要用到的按键

布局实现

class MyFrame extends Frame {
    public MyFrame ()
    {
        Panel panel1 = new Panel();
        Panel panel2 = new Panel();
        Panel panel3 = new Panel();
        TextField textField = new TextField();
        Button button1 = new Button  ("1");
        Button button2 = new Button("2");
        Button button3 = new Button("3");
        Button button4 = new Button("4");
        Button button5 = new Button("5");
        Button button6 = new Button("6");
        Button button7 = new Button("7");
        Button button8 = new Button("8");
        Button button9 = new Button("9");
        Button button0 = new Button("0");
        Button multiple = new Button("*");
        Button divide = new Button("/");
        Button minus = new Button("-");
        Button add = new Button("+");
        Button dot = new Button(".");
        Button equal = new Button("=");
        Button CE = new Button("CE");
        Button left_bracket = new Button("(");
        Button right_bracket = new Button(")");


        setBounds(400,400,800,1000);
        setLayout(new GridLayout(4,1));
        panel1.setLayout(new GridLayout(2,4));
        panel2.setLayout(new GridLayout(2,4));
        panel3.setLayout(new GridLayout(1,3 ));

        panel1.add(button7);
        panel1.add(button8);
        panel1.add(button9);
        panel1.add(add);
        panel1.add(button4);
        panel1.add(button5);
        panel1.add(button6);
        panel1.add(minus);

        panel2.add(button1);
        panel2.add(button2);
        panel2.add(button3);
        panel2.add(multiple);
        panel2.add(dot);
        panel2.add(button0);
        panel2.add(equal);
        panel2.add(divide);

        panel3.add(left_bracket);
        panel3.add(right_bracket);
        panel3.add(CE);

        add(textField);
        add(panel1);
        add(panel2);
        add(panel3);

        button1.addActionListener(new ButtonAction(textField));
        button2.addActionListener(new ButtonAction(textField));
        button3.addActionListener(new ButtonAction(textField));
        button4.addActionListener(new ButtonAction(textField));
        button5.addActionListener(new ButtonAction(textField));
        button6.addActionListener(new ButtonAction(textField));
        button7.addActionListener(new ButtonAction(textField));
        button8.addActionListener(new ButtonAction(textField));
        button9.addActionListener(new ButtonAction(textField));
        button0.addActionListener(new ButtonAction(textField));
        add.addActionListener(new ButtonAction(textField));
        minus.addActionListener(new ButtonAction(textField));
        multiple.addActionListener(new ButtonAction(textField));
        divide.addActionListener(new ButtonAction(textField));
        dot.addActionListener(new ButtonAction(textField));
        equal.addActionListener(new ButtonAction(textField));
        CE.addActionListener(new ButtonAction(textField));
        left_bracket.addActionListener(new ButtonAction(textField));
        right_bracket.addActionListener(new ButtonAction(textField));


        pack();
        setVisible(true);
        WindowClosing();

    }

    public void WindowClosing()
    {
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }

事件监听实现

class ButtonAction implements ActionListener
{
    private TextField textField ;

    public ButtonAction(TextField textField) {
        this.textField = textField;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if(e.getActionCommand().equals("CE"))
        {
            textField.setText("");
        }
        else if(e.getActionCommand().equals("."))
        {
            textField.setText(textField.getText()+e.getActionCommand());
        }
        else if(e.getActionCommand().equals("*") || e.getActionCommand().equals("/") || e.getActionCommand().equals("+") || e.getActionCommand().equals("-") || e.getActionCommand().equals("(") || e.getActionCommand().equals(")"))
        {       
            textField.setText(textField.getText()+e.getActionCommand());
        }
        else if(e.getActionCommand().equals("="))
        {
            TreeCalculate ca = new TreeCalculate();
            String Formula = textField.getText();
            String result = ca.calculator(Formula);
            textField.setText(result); 
        }
        else if(Integer.parseInt(e.getActionCommand()) >= 0 && Integer.parseInt(e.getActionCommand()) <= 9)
        {
            textField.setText(textField.getText()+e.getActionCommand());
        }

    }
}

计算功能实现

我偷了个小懒，因为之前课设做过二叉树实现四则运算的计算器，所以这次没有自己实现计算功能，计算功能用了CSDN博主「奇凡」的写的代码加以魔改
原文链接：https://blog.csdn.net/a477997/article/details/7369151

public class TreeCalculate {

    public String calculator(String formula)
    {
        DecimalFormat df = new DecimalFormat("0.00");
        df.setRoundingMode(RoundingMode.HALF_UP);
        double a = new TreeNode(formula).calculate();
        return  df.format(a);
    }
    
    class TreeNode
    {
        double data;
        char operation;
        TreeNode left;
        TreeNode right;
        
        public TreeNode(String expression)
        {
            char[] exc = toCharArrayTrimOutParenthes(expression);
            if(exc == null)
            {
                return;
            }
            exc = syntaxCheck(exc);
            int length = exc.length;

            int index=0;

            if (hasOperation(exc)) {
                int parenthes = 0;

                for (int i = length - 1; i >= 0; i--) {
                    
                    if(exc[i] == '(')
                    {
                        parenthes --;
                    }else if(exc[i] == ')')
                    {
                        parenthes++;
                    }

                    if (parenthes > 0) {
                        continue;
                    }

                    if(exc[i] == '*' || exc[i] == '/')
                    {
                        index = i;
                    }else if(exc[i] == '+' || exc[i] == '-')
                    {
                        index = i;
                        break;
                    }

                }
                if(isOperation(exc[index]))
                {
                    operation = exc[index];
                }
                StringBuilder sbleft = new StringBuilder();
                StringBuilder sbright = new StringBuilder();

                for(int i=0;i<index;i++)
                {
                    sbleft.append(exc[i]);
                }
                for(int i=index+1;i<length;i++)
                {
                    sbright.append(exc[i]);
                }
                left=new TreeNode(sbleft.toString());
                right= new TreeNode(sbright.toString());


            }
            else
            {
                StringBuilder value= new StringBuilder();
                value.append(exc);
                data = Double.parseDouble(value.toString());
            }
        }
        
        public char[] syntaxCheck(char[] cArray)
        {
            boolean flag = false;
            if(isOperation(cArray[0]))
            {
                char [] checkedArray = new char[cArray.length+1];
                checkedArray[0] = '0';
                for(int i=0;i<cArray.length;i++)
                {
                    checkedArray[i+1] = cArray[i];
                }
                cArray = checkedArray;
            }
            for(int i =0;i<cArray.length;i++)
            {
                if(isOperation(cArray[i]))
                {
                    if(flag == true)
                    {
                        System.out.println("syntaxError");
                    }
                    flag = true;
                }else
                {
                    flag = false;
                }
            }

            return cArray;
        }
 
        public boolean hasOperation(char[] cArray)
        {
            for(int i=0;i<cArray.length;i++)
            {
                if(isOperation(cArray[i]))
                {
                    return true;
                }

            }
            return false;
        }
        public boolean isOperation(char c)
        {
            return (c == '+' || c == '-' || c== '*' || c == '/' );

        }
        
        public char[] toCharArrayTrimOutParenthes(String src)
        {

            if(src.length() == 0)
            {
                return null;
            }
            String result = src;
            while(result.charAt(0) == '(' && result.charAt(result.length()-1) == ')')
            {
                int parenthes = 0;
                for(int i = 0;i<result.length()-1;i++)
                {
                    if(result.charAt(i) == '(')
                    {
                        parenthes++;
                    }
                    else if(result.charAt(i) == ')')
                    {
                        parenthes--;
                    }
                    if(parenthes==0)
                    {
                        return result.toCharArray();
                    }
                }
                result = result.substring(1, result.length()-1);

            }

            return result.toCharArray();
        }

        public double calculate()
        {
            double result=0;
            if(left==null && right ==null)
            {
                result =data;
            }else
            {
                double leftResult =left.calculate();
                double rightResult=right.calculate();
                switch(operation){
                    case '+':
                        result=leftResult + rightResult;
                        break;
                    case '-':
                        result=leftResult - rightResult;
                        break;
                    case '*':
                        result=leftResult * rightResult;
                        break;
                    case '/':
                        result=leftResult / rightResult;
                        break;
                    default: break;
                }
            }
            return result;
        }
    }
}

执行程序

还能凑合用