Java实验——实验5 计算器GUI制作

实验内容

1. 学习使用图形用户界面（GUI）设计实现一个简单的计算器，能进行+- ×/四则运算（注意数字大小的越界考虑，一般计算器输入的数字个数不超过16个）；
2. 学习制作jar包，然后将jar包制作为exe可执行文件（可采用exe4j软件）；
3. 实验报告粘贴Java代码，并截图运行效果，同时上传jar包，如果实现了exe可执行文件，同时上传exe文件。

code

CalculatorSelf.java

package project5;

import javax.swing.*;
import javax.xml.bind.annotation.XmlElementRef;
import java.awt.*;
import java.awt.event.*;
import java.net.URL;

public class CalculatorSelf extends JFrame implements ActionListener {
    int sum = 0;
    int preNumber = 0;
    int tempMul = 1;
    int tempDiv = 1;
    int tempMod = 1;
    int tempSum = 0;
    //记录输入状态    点击数字按钮则为0，如果点击运算符按钮则转为1
    short status = 0;
    //存储前一个运算符  0：无运算符  1：+     2：-     3：×     4：÷     5：%     6：=
    short preOperator = 0;
    JTextField input, tempResult, BIN, OCT, HEX;

    public CalculatorSelf() {
        super("程序员计算器");

    }

    public void init() {
        Container contentPane = getContentPane();

        input = new JTextField();
        tempResult = new JTextField();
        input.setEditable(false);
        tempResult.setEditable(false);
        //用于存放显示框   输入框 2进制、8进制、16进制框
        JPanel TransPanel = new JPanel(new GridLayout(5, 1));

        BIN = new JTextField(50);
        OCT = new JTextField(50);
        HEX = new JTextField(50);
        BIN.setEditable(false);
        OCT.setEditable(false);
        HEX.setEditable(false);

        //文本框初始化
        input.setHorizontalAlignment(JTextField.RIGHT);
        tempResult.setHorizontalAlignment(JTextField.RIGHT);
        BIN.setHorizontalAlignment(JTextField.RIGHT);
        OCT.setHorizontalAlignment(JTextField.RIGHT);
        HEX.setHorizontalAlignment(JTextField.RIGHT);

        tempResult.setBackground(new Color(230, 230, 230));
        input.setBackground(new Color(255, 255, 255));
        BIN.setBackground(new Color(230, 230, 230));
        OCT.setBackground(new Color(230, 230, 230));
        HEX.setBackground(new Color(230, 230, 230));

        TransPanel.add(tempResult);
        TransPanel.add(input);
        TransPanel.add(BIN);
        TransPanel.add(OCT);
        TransPanel.add(HEX);


        //按钮初始化

        Font font = new Font("Times New Roman", Font.BOLD, 16);
        String[] button = {"<<", ">>", "AC", "DEL",
                "7", "8", "9", "+",
                "4", "5", "6", "-",
                "1", "2", "3", "×",
                "+/-", "0", "%", "÷"};
        JPanel buttonPanelUp = new JPanel(new GridLayout(5, 4));
        for (int i = 0; i < 4; i++) {
            JButton temp = new JButton(button[i]);
            temp.setFocusPainted(false);
            buttonPanelUp.add(temp);
            temp.addActionListener(this);
            temp.addMouseListener(new MyMouseListener1());
            temp.setFont(font);
            temp.setBackground(new Color(240, 240, 240));
        }
        //7、8、9按钮初始化
        for (int i = 4; i < 7; i++) {
            JButton temp = new JButton(button[i]);
            temp.setFocusPainted(false);
            buttonPanelUp.add(temp);
            temp.addActionListener(this);
            temp.addMouseListener(new MyMouseListener2());
            temp.setFont(font);
            temp.setBackground(new Color(250, 250, 250));
        }

        //+ 按钮初始化
        JButton addButton = new JButton(button[7]);
        addButton.setFocusPainted(false);
        buttonPanelUp.add(addButton);
        addButton.addActionListener(this);
        addButton.addMouseListener(new MyMouseListener1());
        addButton.setFont(font);
        addButton.setBackground(new Color(240, 240, 240));

        //4、5、6按钮初始化
        for (int i = 8; i < 11; i++) {
            JButton temp = new JButton(button[i]);
            temp.setFocusPainted(false);
            buttonPanelUp.add(temp);
            temp.addActionListener(this);
            temp.addMouseListener(new MyMouseListener2());
            temp.setFont(font);
            temp.setBackground(new Color(250, 250, 250));
        }

        //- 按钮初始化
        JButton subButton = new JButton(button[11]);
        subButton.setFocusPainted(false);
        buttonPanelUp.add(subButton);
        subButton.addActionListener(this);
        subButton.addMouseListener(new MyMouseListener1());
        subButton.setFont(font);
        subButton.setBackground(new Color(240, 240, 240));

        //1、2、3按钮初始话
        for (int i = 12; i < 15; i++) {
            JButton temp = new JButton(button[i]);
            temp.setFocusPainted(false);
            buttonPanelUp.add(temp);
            temp.addActionListener(this);
            temp.addMouseListener(new MyMouseListener2());
            temp.setFont(font);
            temp.setBackground(new Color(250, 250, 250));
        }

        //× 按钮初始化
        JButton mulButton = new JButton(button[15]);
        mulButton.setFocusPainted(false);
        buttonPanelUp.add(mulButton);
        mulButton.addActionListener(this);
        mulButton.addMouseListener(new MyMouseListener1());
        mulButton.setFont(font);
        mulButton.setBackground(new Color(240, 240, 240));

        //+/- 按钮初始化
        JButton sigButton = new JButton(button[16]);
        sigButton.setFocusPainted(false);
        buttonPanelUp.add(sigButton);
        sigButton.addActionListener(this);
        sigButton.addMouseListener(new MyMouseListener1());
        sigButton.setFont(font);
        sigButton.setBackground(new Color(240, 240, 240));

        //0按钮初始化
        JButton zeroButton = new JButton(button[17]);
        zeroButton.setFocusPainted(false);
        buttonPanelUp.add(zeroButton);
        zeroButton.addActionListener(this);
        zeroButton.addMouseListener(new MyMouseListener2());
        zeroButton.setFont(font);
        zeroButton.setBackground(new Color(250, 250, 250));

        //%、= 按钮初始化
        for (int i = 18; i < 20; i++) {
            JButton temp = new JButton(button[i]);
            temp.setFocusPainted(false);
            buttonPanelUp.add(temp);
            temp.addActionListener(this);
            temp.addMouseListener(new MyMouseListener1());
            temp.setFont(font);
            temp.setBackground(new Color(240, 240, 240));
        }
        //buttonPanel.add(buttonPanelUp);

        JButton equalButton = new JButton("=");
        equalButton.setFocusPainted(false);
        equalButton.addActionListener(this);
        equalButton.addMouseListener(new MouseAdapter(){
            @Override
            public void mouseEntered(MouseEvent e) {
                equalButton.setBackground(new Color(72,156,222));
            }

            @Override
            public void mouseExited(MouseEvent e) {
                equalButton.setBackground(new Color(138,186,224));
            }
        });
        equalButton.setFont(font);
        equalButton.setBackground(new Color(138, 186, 224));
        //buttonPanel.add(equalButton);

        contentPane.add(TransPanel);
        contentPane.add(buttonPanelUp);
        contentPane.add(equalButton);


        //这里添加一个Jrame窗口的监听器
        this.addComponentListener(new ComponentAdapter() {
            //监听的事件是窗口的大小变化，如果窗口发生变化，则调整2个panel和“=”的尺寸
            @Override
            public void componentResized(ComponentEvent e) {
                Dimension d = contentPane.getSize();
                TransPanel.setBounds(0,0,d.width,d.height/5);

                buttonPanelUp.setBounds(0,TransPanel.getHeight(),d.width,d.height*2/3);
                equalButton.setBounds(0,TransPanel.getHeight()+buttonPanelUp.getHeight(),d.width,contentPane.getHeight()-TransPanel.getHeight()-buttonPanelUp.getHeight());

            }
        });

        //JFrame初始化设置
        //图标设置
        URL resource = CalculatorSelf.class.getResource("IconImage.png");
        ImageIcon imageIcon = new ImageIcon(resource);
        this.setIconImage(imageIcon.getImage());

        this.setVisible(true);
        this.setBounds(700, 300, 350, 500);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        //this.setResizable(false);

    }

    //这是一个对窗口事件的总监听
    //就是在窗口发生了事件，就会该方法
    @Override
    public void actionPerformed(ActionEvent e) {
        //获取事件对应的行为命令，如果是button，并且没有用setActionCommand显式地定义行为命令，则默认和button的显示字符串一致
        String cmd = e.getActionCommand();
        //如果行为命令是数字
        if (Character.isDigit(cmd.charAt(0))) {
            //如果status=0，说明上一个按键不是运算符
            if(status == 0) {
                //这里做了一个优化：当输入框当前数字为0时，紧接着输入数字会变为'0'+数字
                if (input.getText().equals("0"))
                    input.setText(cmd);
                else
                    input.setText(input.getText() + cmd);
                refresh();
            }
            //否则如果上一个按键是运算符，则这次键入的数字作为新数的输入
            else if(status == 1){
                input.setText(cmd);
                refresh();
                status = 0;
            }
        }
        //如果键入的是运算符，则进行下列的运算处理
        else
            try {
                switch (cmd) {
                    case "<<":
                        shiftLeft();
                        break;
                    case ">>":
                        shiftRight();
                        break;
                    case "AC":
                        clear();
                        break;
                    case "DEL":
                        delete();
                        break;
                    case "+":
                        addSum();
                        break;
                    case "-":
                        subSum();
                        break;
                    case "×":
                        mulSum();
                        break;
                    case "÷":
                        divSum();
                        break;
                    case "+/-":
                        transSig();
                        break;
                    case "%":
                        modSum();
                        break;
                    case "=":
                        equal();
                        break;

                }
            }catch (Exception eq){
                    clear();
                    tempResult.setText("error!");
                }

    }

    //刷新进制转换栏的输出
    public void refresh()
    {
        int i = Integer.parseInt(input.getText());
        BIN.setText(Integer.toBinaryString(i));
        OCT.setText(Integer.toOctalString(i));
        HEX.setText(Integer.toHexString(i));
}
    //二进制左移一位运算
    public void shiftLeft(){
        int i = Integer.parseInt(input.getText());
        i*=2;
        input.setText(Integer.toString(i));
        BIN.setText(Integer.toBinaryString(i));
        OCT.setText(Integer.toOctalString(i));
        HEX.setText(Integer.toHexString(i));
    }
    //二进制右移一位运算
    public void shiftRight(){
        int i = Integer.parseInt(input.getText());
        i/=2;
        input.setText(Integer.toString(i));
        BIN.setText(Integer.toBinaryString(i));
        OCT.setText(Integer.toOctalString(i));
        HEX.setText(Integer.toHexString(i));
    }

    //清除所有文本框的内容，并初始化所有参数
    public void clear(){
        status = 0;
        sum = 0;
        tempSum = 0;
        preOperator = 0;
        preNumber = 0;
        tempMul = 1;
        tempDiv = 1;
        tempResult.setText("");
        input.setText("");
        BIN.setText("");
        OCT.setText("");
        HEX.setText("");
    }

    //删除一个输入
    public void delete(){
        String s = input.getText();
        if(s.length()>0) {
            input.setText(s.substring(0, s.length() - 1));
            if(input.getText().length()==0)
                input.setText("0");
            refresh();
        }
    }

    //键入“+”执行方法
    public void addSum(){
            //获取当前输入框的数
            preNumber = Integer.parseInt(input.getText());
            preprocess();
            tempResult.setText(tempResult.getText() + input.getText() + "+");
            input.setText(Integer.toString(sum));
            status = 1;
            preOperator = 1;

    }

    //键入“-”执行方法
    public void subSum(){
            preNumber = Integer.parseInt(input.getText());
            preprocess();
            tempResult.setText(tempResult.getText() + input.getText() + "-");
            input.setText(Integer.toString(sum));

            status = 1;
            preOperator = 2;

    }

    //键入“×”执行方法
    public void mulSum(){
            preNumber = Integer.parseInt(input.getText());
            //判断上一个运算符是哪种运算符
            //temMul存储进行乘法运算暂存的结果
            switch (preOperator) {
                //0则说明上一次无运算符输入，则直接将输入框的数作为temMul的第一个乘数
                case 0:
                    tempMul = preNumber;
                    break;
                    //如果上一个是加法运算符，则直接将输入框的数作为tempMul的第一个乘数
                case 1:
                    tempMul = preNumber;
                    break;
                //如果上一个是减法运算符，则将输入框的数的负数作为tempMul的第一个乘数
                case 2:
                    tempMul = -1 * preNumber;
                    break;
                    //如果上一个是乘法运算符，则直接将输入框的数和tempMul相乘即可
                case 3:
                    tempMul *= preNumber;
                    break;
                case 4:
                    //如果上一个是除法运算符，则用tempDiv除以输入框的数，完成上一次的除法运算
                    //这里做了一个异常处理，若出现除数为0的情况，直接在第1行显示error！,并重置
                    try {
                        tempMul = tempDiv / preNumber;
                    }
                    catch (Exception eq){
                    clear();
                    tempResult.setText("error!");
                }
                    break;
                    //如果上一个是取余运算符，则用tempMod对输入框的数进行取余，完成上一次的取余操作
                case 5:
                    tempMul = tempMod % preNumber;
                    break;
                    //如果上一次是等于号，则直接将输入框的数作为tempMul的第一个乘数，并清除第1行内容
                case 6:
                    sum = 0;
                    tempMul = preNumber;
                    tempResult.setText("");
                    break;
            }
            //更新第1行的显示
            tempResult.setText(tempResult.getText() + input.getText() + "×");
            status = 1;
        preOperator = 3;
    }

    public void divSum(){
            preNumber = Integer.parseInt(input.getText());
        //判断上一个运算符是哪种运算符
        //temDiv存储进行乘法运算暂存的结果
            switch (preOperator) {
                //0则说明上一次无运算符输入，则直接将输入框的数作为temDiv的第一个数
                case 0:
                    tempDiv = preNumber;
                    break;
                //如果上一个是加法运算符，则直接将输入框的数作为tempDiv的第一个数
                case 1:
                    tempDiv = preNumber;
                    break;
                //如果上一个是减法运算符，则将输入框的数的负数作为tempDiv的第一个数
                case 2:
                    tempDiv = -1 * preNumber;
                    break;
                //如果上一个是乘法运算符，则用tempMul乘以输入框的数，完成上一次的乘法运算
                case 3:
                    tempDiv = tempMul * preNumber;
                    break;
                //如果上一个是除法运算符，则直接用tempDiv除以输入框的数即可
                //这里做了一个异常处理，若出现除数为0的情况，直接在第1行显示error！,并重置
                case 4:
                    try {
                        tempDiv /= preNumber;
                    }
                    catch (Exception eq){
                    clear();
                    tempResult.setText("error!");
                }
                    break;
                //如果上一个是取余运算符，则用tempMod对输入框的数进行取余，完成上一次的取余操作
                case 5:
                    tempDiv = tempMod % preNumber;
                    break;
                //如果上一次是等于号，则直接将输入框的数作为tempMul的第一个乘数，并清除第1行内容
                case 6:
                    sum = 0;
                    tempDiv = preNumber;
                    tempResult.setText("");
                    break;
            }
            //更新第1行的显示
            tempResult.setText(tempResult.getText() + input.getText() + "÷");
            status = 1;
            preOperator = 4;

    }

    //转负数
    public void transSig(){
         input.setText("-"+input.getText());
    }

    public void modSum(){
            preNumber = Integer.parseInt(input.getText());
            switch (preOperator) {
                //0则说明上一次无运算符输入，则直接将输入框的数作为temMod的第一个数
                case 0:
                    tempMod = preNumber;
                    break;
                //如果上一个是加法运算符，则直接将输入框的数作为tempMod的第一个数
                case 1:
                    tempMod = preNumber;
                    break;
                //如果上一个是减法运算符，则将输入框的数的负数作为tempMod的第一个数
                case 2:
                    tempMod = -1 * preNumber;
                    break;
                //如果上一个是乘法运算符，则用tempMul乘以输入框的数，完成上一次的乘法运算
                case 3:
                    tempMod = tempMul * preNumber;
                    break;
                //如果上一个是除法运算符，则直接用tempDiv除以输入框的数即可
                //这里做了一个异常处理，若出现除数为0的情况，直接在第1行显示error！,并重置
                case 4:
                    try {
                        tempMod = tempDiv / preNumber;
                    }
                    catch (Exception eq){
                    clear();
                    tempResult.setText("error!");
                }
                    break;
                //如果上一个是取余运算符，则直接用tempMod对输入框的数进行取余
                case 5:
                    tempMod %= preNumber;
                    break;
                //如果上一次是等于号，则直接将输入框的数作为tempMul的第一个乘数，并清除第1行内容
                case 6:
                    sum = 0;
                    tempMod = preNumber;
                    tempResult.setText("");
                    break;
            }
            //更新第1行的显示
            tempResult.setText(tempResult.getText() + input.getText() + "%");
            status = 1;
            preOperator = 5;
    }

    //+、-运算符处理
    public void preprocess(){
        tempSum = sum;
        switch (preOperator){
            //0则说明上一次无运算符输入，则直接将输入框的数作为sum的第一个数
            case 0:
                sum = preNumber;
                break;
            //如果上一个是加法运算符，sum直接+输入框的数
            case 1:
                sum+=preNumber;
                break;
            //如果上一个是减法运算符，sum直接-输入框的数
            case 2:
                sum-=preNumber;
                break;
            //如果上一个是乘法运算符，则用tempMul乘以输入框当前的数，完成最后一次乘法运算，再将结果和sum相加
            case 3:
                tempMul*=preNumber;
                sum+=tempMul;
                break;
            //如果上一个是除法运算符，则用tempDiv除以输入框当前的数，完成最后一次除法运算，再将结果和sum相加
            case 4:
                try {
                    tempDiv/=preNumber;
                    sum+=tempDiv;
                }
                catch (Exception eq){
                    clear();
                    tempResult.setText("error!");
                }

                break;
            //如果上一个是取余运算符，则用tempMod对输入框当前的数取余，完成最后一次取余运算，再将结果和sum相加
            case 5:
                tempMod%=preNumber;
                sum+=tempMod;
                break;
            //如果上一个是等于运算符，则直接将输入框的数作为sum的第一个数
            case 6:
                sum = preNumber;
                tempResult.setText("");
                break;
        }
        refresh();
    }

    public void equal(){
        try {
            //判断上一个运算符是否也是等于运算符，这里是防止进行连续多次的等于运算
            if(preOperator!=6) {
                int num = Integer.parseInt(input.getText());
                tempResult.setText(tempResult.getText() + input.getText() + "=");
                switch (preOperator) {
                    //如果上一个是加法运算符，sum直接+输入框的数
                    case 1:
                        sum += num;
                        break;
                    //如果上一个是减法运算符，sum直接-输入框的数
                    case 2:
                        sum -= num;
                        break;
                    //如果上一个是乘法运算符，则用tempMul乘以输入框当前的数，完成最后一次乘法运算，再将结果和sum相加
                    case 3:
                        tempMul *= num;
                        sum += tempMul;
                        break;
                    //如果上一个是除法运算符，则用tempDiv除以输入框当前的数，完成最后一次除法运算，再将结果和sum相加
                    case 4:
                        try {
                            tempDiv /= num;
                            sum += tempDiv;
                        }
                        catch (Exception eq){
                        clear();
                        tempResult.setText("error!");
                    }
                        break;
                    //如果上一个是取余运算符，则用tempMod对输入框当前的数取余，完成最后一次取余运算，再将结果和sum相加
                    case 5:
                        tempMod %= num;
                        sum += tempMod;
                        break;
                    default:
                        sum = num;
                        break;
                }
                input.setText(Integer.toString(sum));
                refresh();
                preOperator = 6;
            }
        }catch (Exception e){

        }

    }


    //以下为鼠标移入按钮和移出按钮事件的处理：改变按钮颜色
    class MyMouseListener1 extends MouseAdapter{
        @Override
        public void mouseEntered(MouseEvent e) {
            e.getComponent().setBackground(new Color(220,220,220));
        }

        @Override
        public void mouseExited(MouseEvent e) {
            e.getComponent().setBackground(new Color(240,240,240));
        }
    }

    class MyMouseListener2 extends MouseAdapter{
        @Override
        public void mouseEntered(MouseEvent e) {
            e.getComponent().setBackground(new Color(220,220,220));
        }

        @Override
        public void mouseExited(MouseEvent e) {
            e.getComponent().setBackground(new Color(250,250,250));
        }
    }

    public static void main(String[] args) {
        new CalculatorSelf().init();
    }

}

大概实现思路

该程序员计算器是在满足基础运算的情况下做了一些方便程序设计的拓展，拓展思路参考自win10程序员计算器：

但是其中一些功能并未实现：

1. 不能在除十进制外的进制输入；
2. 没有括号功能；
3. 不能通过键盘输入（其实这个知道怎么实现，就是使用KeyListener，制作初期也想到要弄这个功能，但是打包完之后才想起来，想想貌似键盘输入的必要也不是很大）
4. 在键入运算符后，不能更改运算符（但在这里采取了一个措施是按一次运算符则作为要进行一次运算）

其中第1行文本框为保存输入，第2行为输入数字，第3行结果的二进制转换，第4行为结果的八进制转换，第5行为结果的十六进制转换。

整体运行思路

通过按钮输入数字会显示在第2行，在按下一个输入运算符的按钮后，会保存第2行当前的数值，再判断前一次运算符，从而将当前输入框的数值进行运算，更新结果（正因如此，所以在按下一个运算符后无法更改），结果会显示在第2行，而二进制、八进制、十六进制框会随着第2行数值的更新而更新。

左移和右移的策略是对二进制进行一位的左/右移操作。

优化

优化主要是对界面的优化

1. 按钮和文本框会随着Jframe的大小而变化；
2. 按钮做了取消聚焦、鼠标移动到按钮上就会出现颜色变化（具体颜色也是取色自win10计算器）的优化；
3. 按下一次“=”号后，再次输入会刷新第1行的显示。

运行效果

进行简单的加减乘除取余运算：

左移、右移运算：

原：

左移2次：

右移4次：

复杂（混合）运算：

这里要声明一个我们平时不太接触的运算优先级：

取余和乘除的优先级是相同的，谁在前先算谁。

测试删除键：

按了一次删除键（DEL）：

紧接着可以根据输入栏剩下的结果继续运算：

×3：

按钮及文本框尺寸跟随窗体大小变化而变化：

但是这里有一个我不理解的地方：

我是利用ComponentResized直接监听窗体尺寸的变化来修改panel的尺寸，直接拽拉窗体尺寸的变化都没问题。但是，但是，但是，直接按最大化或还原按钮的话会出现这样的情况：

直接最大化：

但是此时按最小化按钮再重新显示，panel就正常修改尺寸了：

还原也一样：

最小化后重新显示：

这个bug一直弄不懂是为什么。

我的布局是容器内装了2个panel和一个“=”按钮，采用默认的布局。2个panel都采用GridLayout布局。

不过听说可以使用BoxLayout布局管理器，不会出现以上bug……

以上几乎就是本人自制程序员计算器的全部功能。

关于打包生成exe文件的说明

网上有很多详细的教程，大多同学使用eclipse做实验，而我自己用的开发工具是idea，打包的步骤可能不太相同，所以就不在这里放打jar包的教程了，jar包生成exe文件的软件推荐大家直接上exe4j官网下载exe4j的最新版使用：https://www.ej-technologies.com/download/exe4j/files