Java编写得计算器-窗体程序有详细设计文档和报告

喜欢ヅ旅行 2024-03-27 15:55 61阅读 0赞

今天为大家分享一个Java语言编写的计算器的开发与制作。系统用Java语言编写，整个系统界面漂亮，有完整的源码，希望大家可以喜欢。喜欢的帮忙点赞和关注。一起编程、一起进步

## 开发环境 ##

开发语言为Java，开发环境Eclipse或者IDEA都可以。数据库采用：MySQL。运行主程序，或者执行打开JAR文件即可以运行本程序。

## 系统框架 ##

利用JDK自带的SWING框架开发，不需要安装第三方JAR包。MySQL数据库，纯窗体模式，直接运行Main文件即可以。同时带有详细得设计文档

## 主要功能 ##

用Java语言编写一个简单的计算器，使得其能够实现最基本的功能。如简单的加、减、乘、除、平方

根、倒数等功能。整个系统界面简洁，使用方便，具有良好的可推广性和扩展性。

### 设计思路 ###

输入：允许输入带有括号的完整计算式（例 8\*（4-95)+5÷2\*e-pi）

输出：输出Double类型的结果 输出：整个运算表达式并保存于历史记录中

部分功能点：基本的加，减，乘，除，四则运算 平方运算 开方运算 求余运算

### 难点和关键点 ###

从左向右依次读取算术表达式的元素X，分以下情况进行不同的处理：

（1）如果X是操作数，直接入队

（2）如果X是运算符，再分以下情况：

a）如果栈为空，直接入栈。

b）如果X==”（“，直接入栈。

c）如果X==”）“，则将栈里的元素逐个出栈，并入队到后缀表达式队列中，直到第一个配对的”(”出栈。（注：“(”和“)”都不 入队）

d）如果是其他操作符（+ - \* /）,则和栈顶元素进行比较优先级。 如果栈顶元素的优先级大于等于X，则出栈并把栈中弹出的元素入队，直到栈顶元素的优先级小于X或者栈为空。弹出完这些元素后，才将遇到的操作符压入到栈中。

(3)最后将栈中剩余的操作符全部入队。

## 运行效果 ##

![954da6d4924cd9586c9fbbc8ceab3a35.jpeg][]

## 全部代码 ##

public class Cal extends JFrame implements ActionListener {
        // Main函数入口
        public static void main(String args[]) {
            Cal cal = new Cal();// new一个对象
            cal.setVisible(true);// 设置为可视
            cal.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 计算器自带关闭的按钮，方便用户关闭窗口
        }
    
        private static final long serialVersionUID = 1L;
        // 计算器上的键的显示名字
        private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
                "*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
        // 计算器上的功能键的显示名字
        private final String[] COMMAND = { "回退", "CE", "C" };
        // 计算器左边的M的显示名字
        private final String[] M = { " ", "MC", "MR", "MS", "M+" };
        // 计算器上键的按钮
        private JButton keys[] = new JButton[KEYS.length];
        // 计算器上的功能键的按钮
        private JButton commands[] = new JButton[COMMAND.length];
        // 计算器左边的M的按钮
        private JButton m[] = new JButton[M.length];
    
        // 计算器最上方结果文本框
        private JTextField resultText = new JTextField("0");
    
        // 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
        private boolean firstDigit = true;
        // 计算的中间结果。
        private double resultNum = 0.0;
        // 当前运算的运算符
        private String operator = "=";
        // 操作是否合法
        private boolean operateValidFlag = true;
        JMenu seeMenu, editMenu, helpMenu;
        JMenuItem seesubMenu;
        JMenuItem copyMenu, pasteMenu;
        JMenuItem helpsubMenu;
    
        // 通过下面这两句获取系统粘贴板，通过调用系统函数来完成复制
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Clipboard clipBoard = toolkit.getSystemClipboard();
    
        // 初始化菜单函数，对菜单和子菜单初始化
        public JMenuBar initMenu() {
            JMenuBar menuBar = new JMenuBar();
            // 初始化查看菜单
            seeMenu = new JMenu("查看");
            seesubMenu = new JMenuItem("查看详情");
            seeMenu.add(seesubMenu);
            // 初始化编辑菜单
            editMenu = new JMenu("编辑");
            copyMenu = new JMenuItem("复制");
            pasteMenu = new JMenuItem("粘贴");
            editMenu.add(copyMenu);
            editMenu.add(pasteMenu);
    
            // 初始化帮助菜单
            helpMenu = new JMenu("帮助");
            helpsubMenu = new JMenuItem("查看帮助");
            helpMenu.add(helpsubMenu);
    
            seesubMenu.addActionListener(this); // 设置查看菜单响应事件
            copyMenu.addActionListener(this); // 设置响应事件
            pasteMenu.addActionListener(this); // 设置响应事件
            helpsubMenu.addActionListener(this); // 设置响应事件
    
            menuBar.add(seeMenu);// 添加到menuBar中
            menuBar.add(editMenu);// 添加到menuBar中
            menuBar.add(helpMenu);// 添加到menuBar中
            return menuBar;
        }
    
        /**
         * 构造函数
         */
        public Cal() {
            super();
            // 初始化计算器
            initUI();
            this.setTitle("基于Java Swing的计算器");
            this.setLocation(500, 300);
            // 不许修改计算器的大小
            this.setResizable(false);
            // 设置窗体大小
            this.setSize(550, 300);
            // 初始化菜单
            this.setJMenuBar(initMenu());
        }
    
        /**
         * 初始化计算器
         */
        private void initUI() {
            // 文本框中的内容采用右对齐方式
            resultText.setHorizontalAlignment(JTextField.RIGHT);
            // 不允许修改结果文本框
            resultText.setEditable(false);
            // 设置文本框背景颜色为白色
            resultText.setBackground(Color.WHITE);
    
            // 初始化计算器上键的按钮，将键放在一个画板内
            JPanel calckeysPanel = new JPanel();
            // 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
            calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
            for (int i = 0; i < KEYS.length; i++) {
                keys[i] = new JButton(KEYS[i]);
                calckeysPanel.add(keys[i]);
                keys[i].setForeground(Color.blue);
            }
    
            // 初始化功能键。将功能键放在一个画板内
            JPanel commandsPanel = new JPanel();
            // 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
            commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
            for (int i = 0; i < COMMAND.length; i++) {
                commands[i] = new JButton(COMMAND[i]);
                commandsPanel.add(commands[i]);
            }
    
            // 初始化M键，将M键放在一个画板内
            JPanel calmsPanel = new JPanel();
            // 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
            calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
            for (int i = 0; i < M.length; i++) {
                m[i] = new JButton(M[i]);
                calmsPanel.add(m[i]);
    
            }
    
            // 下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
            // 将文本框放在北部，将calms画板放在计算器的西部。
            // 新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
            JPanel panel1 = new JPanel();
            // 画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
            panel1.setLayout(new BorderLayout(3, 3));
            panel1.add("North", commandsPanel);
            panel1.add("Center", calckeysPanel);
    
            // 建立一个画板放文本框
            JPanel top = new JPanel();
            top.setLayout(new BorderLayout());
            top.add("Center", resultText);
            // 整体布局
            getContentPane().setLayout(new BorderLayout(3, 5));
            getContentPane().add("North", top);
            getContentPane().add("Center", panel1);
            getContentPane().add("West", calmsPanel);
            // 为各按钮添加事件侦听器
            // 都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
            for (int i = 0; i < KEYS.length; i++) {
                keys[i].addActionListener(this);
            }
            for (int i = 0; i < COMMAND.length; i++) {
                commands[i].addActionListener(this);
            }
            for (int i = 0; i < M.length; i++) {
                m[i].addActionListener(this);
            }
        }
    
        /**
         * 响应事件函数
         */
        public void actionPerformed(ActionEvent e) {
            // 获取事件源的标签
            String label = e.getActionCommand();
            if (label.equals(COMMAND[0])) {
                // 如果"Backspace"键，处理回车事件，调用下面的函数
                handleBackspace();
            } else if (label.equals(COMMAND[1])) {
                // 用户按了"CE"键，，调用下面的函数
                resultText.setText("0");// 结果设置为0
            } else if (label.equals(COMMAND[2])) {
                // 用户按了"C"键，，调用下面的函数
                handleC();
            } else if ("0123456789.".indexOf(label) >= 0) {
                // 用户按了数字键或者小数点键，，调用下面的函数
                handleNumber(label);
            } else if (label.equalsIgnoreCase("查看详情")) {
                // 如果点击了查看详情菜单，则跳出提示
                JOptionPane.showMessageDialog(this, "查看详情");
            } else if (label.equalsIgnoreCase("查看帮助")) {
                // 如果点击了查看详情菜单，则跳出：Java Swing计算器，欢迎使用！
                JOptionPane.showMessageDialog(this, "Java Swing计算器，欢迎使用！");
            } else if (label.equalsIgnoreCase("复制")) {
                // 如果点击了复制菜单，把结果的内容复制到系统粘贴板上，并且复制菜单不可用，粘贴菜单可用！
                String text = resultText.getText();
                StringSelection selection = new StringSelection(text);// 构建String数据类型
                clipBoard.setContents(selection, null);// 添加文本到系统剪切板
                copyMenu.setEnabled(false);
                pasteMenu.setEnabled(true);
            }
    
            else if (label.equalsIgnoreCase("粘贴")) {
                // 如果点击了粘贴菜单，把系统粘贴板的数据复制到粘贴板上，并复制菜单可用，粘贴菜单不可用！
                Transferable contents = clipBoard.getContents(this);
                if (contents == null)
                    return;
                String text = "";
                try {
                    text = (String) contents
                            .getTransferData(DataFlavor.stringFlavor); // 获取粘贴板中的内容
                    System.out.println("text is:" + text);
                    resultText.setText(text);
    
                } catch (Exception exception) {
                    exception.printStackTrace();
                }
                copyMenu.setEnabled(true);
                pasteMenu.setEnabled(false);
                // JOptionPane.showMessageDialog(this,"粘贴");
            } else {
                // 用户按了运算符键
                handleOperator(label);
            }
        }
    
        /**
         * 回车键对应业务逻辑
         */
        private void handleBackspace() {
            String text = resultText.getText();
            int i = text.length();
            if (i > 0) {
                // 退格，将文本最后一个字符去掉
                text = text.substring(0, i - 1);
                if (text.length() == 0) {
                    // 如果文本没有了内容，则初始化计算器的各种值
                    resultText.setText("0");
                    firstDigit = true;
                    operator = "=";
                } else {
                    // 显示新的文本
                    resultText.setText(text);
                }
            }
        }
    
        /**
         * 处理数字键被按下的事件
         */
        private void handleNumber(String key) {
            if (firstDigit) {
                // 输入的第一个数字
                resultText.setText(key);
            } else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
                // 输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
                resultText.setText(resultText.getText() + ".");
            } else if (!key.equals(".")) {
                // 如果输入的不是小数点，则将数字附在结果文本框的后面
                resultText.setText(resultText.getText() + key);
            }
            // 以后输入的肯定不是第一个数字了
            firstDigit = false;
        }
    
        /**
         * 处理C键被按下的事件
         */
        private void handleC() {
            // 初始化计算器的各种值
            resultText.setText("0");
            firstDigit = true;
            operator = "=";
        }
    
        /**
         * 处理运算符键被按下的事件，完成业务逻辑，并且显示结果
         */
        private void handleOperator(String key) {
            if (operator.equals("/")) {
                // 除法运算
                // 如果当前结果文本框中的值等于0
                if (getNumberFromText() == 0.0) {
                    // 操作不合法
                    operateValidFlag = false;
                    resultText.setText("除数不能为零");
                } else {
                    resultNum /= getNumberFromText();
                }
            } else if (operator.equals("1/x")) {
                // 倒数运算
                if (resultNum == 0.0) {
                    // 操作不合法
                    operateValidFlag = false;
                    resultText.setText("零没有倒数");
                } else {
                    resultNum = 1 / resultNum;
                }
            } else if (operator.equals("+")) {
                // 加法运算
                resultNum += getNumberFromText();
            } else if (operator.equals("-")) {
                // 减法运算
                resultNum -= getNumberFromText();
            } else if (operator.equals("*")) {
                // 乘法运算
                resultNum *= getNumberFromText();
            } else if (operator.equals("sqrt")) {
                // 平方根运算
                resultNum = Math.sqrt(resultNum);
            } else if (operator.equals("%")) {
                // 百分号运算，除以100
                resultNum = resultNum / 100;
            } else if (operator.equals("+/-")) {
                // 正数负数运算
                resultNum = resultNum * (-1);
            } else if (operator.equals("=")) {
                // 赋值运算
                resultNum = getNumberFromText();
            }
            if (operateValidFlag) {
                // 双精度浮点数的运算
                long t1;
                double t2;
                t1 = (long) resultNum;
                t2 = resultNum - t1;
                if (t2 == 0) {
                    resultText.setText(String.valueOf(t1));
                } else {
                    resultText.setText(String.valueOf(resultNum));
                }
            }
            // 运算符等于用户按的按钮
            operator = key;
            firstDigit = true;
            operateValidFlag = true;
        }
    
        // 从结果文本框中获取数字的函数
        private double getNumberFromText() {
            double result = 0;
            try {
                // 把resultText的文本转换成数字，返回一个Double类型的
                result = Double.valueOf(resultText.getText()).doubleValue();
            } catch (NumberFormatException e) {
                // 转换异常，不做任何处理，返回为0
            }
            return result;
        }
    
    }

[954da6d4924cd9586c9fbbc8ceab3a35.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d64c19b14c8f448180fbd53c35ff94fa.png