实验一简易计算器

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量247 收藏 1
点赞数 3
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxiaomi3/article/details/121544345
版权

实验一 计算器的程序制作
一.项目概述
1.项目目标和主要内容
用Java.swing来实现一个简单计算器，计算器界面的实现和核心算法的编写。
2.要实现的功能
（1基本的加，减，乘，除，四则运算
（2平方运算
（3开方运算
（4求余运算
(5)可显示输入运算及输出结果
二.项目设计
1.编写过成
（1）构建计算器框架。
（2）插入计算器按钮数字及符号采用同大小80*40并注册监听器。
（3）编写中缀表达式转换为后缀表达式，计算开放，平方等运算。
2.关键算法分析
在这里插入图片描述

从左向右依次读取算术表达式的元素X，分以下情况进行不同的处理:
(1)如果X是操作数，直接入队
(2)如果X是运算符，再分以下情况:
a)如果栈为空，直接入栈。
b)如果X==”(“，直接入栈。
c)如果X==”)“，则将栈里的元素逐个出栈，并入队到后缀表达式队列中，直到第一 个配对的"("出栈。 (注:“”和“)”都不入队)
d)如果是其他操作符(±*1) ，则和栈顶元素进行比较优先级。如果栈顶元素的优先级大于等于X,则出栈并把栈中弹出的元素入队，直到栈顶元素的优先级小于X或者栈为空。弹出完这些元素后，才将遇到的操作符压入到栈中。
(3)最后将栈中剩余的操作符全部入队。
在这里插入图片描述
首先准备-一个栈Res_ Stack.
1、从左开始向右遍历后缀表达式的元素。
2、如果取到的元素是操作数，直接入栈Res _Stack， 如果是运算符，从栈中弹出2个数进行运算，然后把运算结果入栈
3、当遍历完后缀表达式时，计算结果就保存在栈里了。
三.程序运行结果
在这里插入图片描述
在这里插入图片描述

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Objects;

import javax.swing.*;
class Calculator extends JFrame implements ActionListener {
    private final String[] KEYS = { "7", "8", "9", "AC", "e", "pi", "6", "5", "4", "+", "-", "sqrt", "1", "2", "3", "*", "/",
            "%", "0", ".", "(", ")", "=", "x^x" };
    private JButton keys[] = new JButton[KEYS.length];
    private JTextArea resultText = new JTextArea("0.0");
    private JTextArea History = new JTextArea();
    private JPanel jp2=new JPanel();
    private JScrollPane gdt1=new JScrollPane(resultText);
    private JScrollPane gdt2=new JScrollPane(History);//新建一个垂直滚动滑条
    private String b = "";
    int flash=0;
    int flash2=0;
    int flash3=0;

    public Calculator() {
        super("hu的计算器");

        JPanel jp1 = new JPanel();
        jp1.setBounds(20,18,255,215);//计算过程面板窗口位置及大小
        jp1.setLayout(new GridLayout());
        jp2.setBounds(290,18,250,215);//历史记录面板窗口位置及大小
        jp2.setLayout(new GridLayout());

        resultText.setLineWrap(true);
        resultText.setWrapStyleWord(true);
        History.setLineWrap(true);
        History.setWrapStyleWord(true);//两个窗口激活自动换行

        History.setEditable(false);// 文本框不允许修改结果
        resultText.setEditable(false);
        gdt1.setViewportView(resultText);//使滚动条显示出来
        gdt2.setViewportView(History);
        gdt1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        gdt2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
        jp1.add(gdt1);//将滚动条添加入面板窗口中
        jp2.add(gdt2);
        this.add(jp1);
        this.add(jp2);//将面板添加到总窗体中
        this.setLayout(null);
        // 放置按钮
        int x = 10, y = 250;
        for (int i = 0; i < KEYS.length; i++)
        {
            keys[i] = new JButton();
            keys[i].setText(KEYS[i]);
            keys[i].setBounds(x, y, 80, 40);
            if (x < 385) {
                x += 90;
            } else {
                x = 10;
                y += 45;
            }
            this.add(keys[i]);
        }
        for (int i = 0; i < KEYS.length; i++)// 每个按钮都注册事件监听器
        {
            keys[i].addActionListener(this);
        }
        this.setResizable(false);
        this.setBounds(500, 200, 567, 480);
        this.setVisible(true);
    }

    // 事件处理
    public void actionPerformed(ActionEvent e)
    {
        //History.setText(b);//使输入的表达式显示在历史记录文本框中
        String label=e.getActionCommand();//获得事件源的标签
        if(Objects.equals(label, "="))//
        {
            resultText.setText(this.b);
            History.setText(History.getText()+resultText.getText());
            if(label.equals("="))//调用计算方法，得出最终结果
            {
                String[] s =houzhui(this.b);
                String result=Result(s);
                this.b=result+"";
                //更新文本框，当前结果在字符串b中，并未删除，下一次输入接着此结果以实现连续运算
                resultText.setText(this.b);
                History.setText(History.getText()+"="+resultText.getText()+"\n");
            }
        }
        else if(Objects.equals(label, "AC"))//清空按钮，消除显示屏文本框前面所有的输入和结果
        {
            this.b="";
            resultText.setText("0");//更新文本域的显示，显示初始值;
            flash=0;
        }
        else if(Objects.equals(label, "sqrt"))
        {
            String n=kfys(this.b);
            resultText.setText("sqrt"+"("+this.b+")"+"="+n);//使运算表达式显示在输入界面
            History.setText(History.getText()+"sqrt"+"("+this.b+")"+"=");//获取输入界面的运算表达式并使其显示在历史记录文本框
            this.b=n;
        }
        else if(Objects.equals(label, "x*x"))
        {
            String m=pfys(this.b);
            resultText.setText(this.b+"^2"+"="+m);//使运算表达式显示在输入界面
            History.setText(History.getText()+this.b+"^2"+"=");//获取输入界面的运算表达式并使其显示在历史记录文本框
            this.b=m;
        }
        else if(Objects.equals(label, "e") || Objects.equals(label, "pi"))
        {
            if(label.equals("e"))
            {
                String m=String.valueOf(2.71828);//将e的值以字符串的形式传给m
                this.b=this.b+m;//保留显示m之前输入的运算符或数字字符继续下一步运算
                resultText.setText(this.b);
                // History.setText(History.getText()+this.b);
            }
            if(label.equals("pi"))
            {
                String m=String.valueOf(3.14159265);
                this.b=this.b+m;
                resultText.setText(this.b);
                // History.setText(History.getText()+this.b);
            }
        }
        else if(label.equals(".")){

            if(flash==0){
                this.b=this.b+label;
                resultText.setText(this.b);
                flash=1;
            }
        }
        else if(label.equals("(")) {
            flash2++;
            if ((b.charAt(b.length()-1)!=')')&&(b.charAt(b.length()-1)!='0') &&(b.charAt(b.length()-1)!='1') &&(b.charAt(b.length()-1)!='2')&&(b.charAt(b.length()-1)!='3') &&(b.charAt(b.length()-1)!='4') &&(b.charAt(b.length()-1)!='5')&&(b.charAt(b.length()-1)!='6') &&(b.charAt(b.length()-1)!='7') &&(b.charAt(b.length()-1)!='8')&&(b.charAt(b.length()-1)!='9') )  {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals(")")) {
             flash3++;
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*') &&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%'&&(b.charAt(b.length()-1)!='(') &&flash2>=flash3)) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }

        else if(label.equals("+")) {
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*') &&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%')&&(b.charAt(b.length()-1)!='(')&&(b.charAt(b.length()-1)!='(') ) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals("-")) {
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*')&&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%')&&(b.charAt(b.length()-1)!='(')&&(b.charAt(b.length()-1)!='(') ) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals("*")) {
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*') &&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%')&&(b.charAt(b.length()-1)!='(')&&(b.charAt(b.length()-1)!='(') ) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals("/")) {
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*') &&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%')&&(b.charAt(b.length()-1)!='(')&&(b.charAt(b.length()-1)!='(') ) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals("%")) {
            if ((b.charAt(b.length()-1)!='/') &&(b.charAt(b.length()-1)!='*') &&(b.charAt(b.length()-1)!='+')&&(b.charAt(b.length()-1)!='-')&&(b.charAt(b.length()-1)!='%')&&(b.charAt(b.length()-1)!='(')&&(b.charAt(b.length()-1)!='(') ) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else
        {
            if(label.equals("+")||label.equals("-")||label.equals("*")||label.equals("/")||label.equals("%"))flash=0;
            this.b=this.b+label;
            resultText.setText(this.b);
            // History.setText(History.getText()+this.b);

        }
        //History.setText(History.getText()+this.b);//使输入的表达式显示在历史记录文本框中

    }
    //将中缀表达式转换为后缀表达式
    private String[] houzhui(String str) {
        String s = "";// 用于承接多位数的字符串
        char[] opStack = new char[100];// 静态栈,对用户输入的操作符进行处理，用于存储运算符
        String[] postQueue = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
        int top = -1, j = 0;// 静态指针top,控制变量j
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='('&&str.charAt(i+1)=='-'){//将"(-"变为”（0-“
                str=str.substring(0,i+1)+"0"+str.substring(i+1);
            }
        }
        for (int i = 0; i < str.length(); i++)// 遍历中缀表达式
        // indexof函数，返回字串首次出现的位置；charAt函数返回index位置处的字符；
        {
            if ("0123456789.".indexOf(str.charAt(i)) >= 0) // 遇到数字字符的情况直接入队
            {
                s = "";// 作为承接字符，每次开始时都要清空
                for (; i < str.length() && "0123456789.".indexOf(str.charAt(i)) >= 0; i++) {
                    s = s + str.charAt(i);
                    //比如，中缀表达式：234+4*2，我们扫描这个字符串的时候，s的作用相当于用来存储长度为3个字符的操作数：234
                }
                i--;
                postQueue[j] = s;// 数字字符直接加入后缀表达式
                j++;
            }
            else if ("(".indexOf(str.charAt(i)) >= 0) {// 遇到左括号
                top++;
                opStack[top] = str.charAt(i);// 左括号入栈
            }
            else if (")".indexOf(str.charAt(i)) >= 0) {// 遇到右括号
                for (;;)// 栈顶元素循环出栈，直到遇到左括号为止
                {
                    if (opStack[top] != '(') {// 栈顶元素不是左括号
                        postQueue[j] = opStack[top] + "";// 栈顶元素出栈
                        j++;
                        top--;
                    } else { // 找到栈顶元素是左括号
                        top--;// 删除栈顶左括号
                        break;// 循环结束
                    }
                }
            }
            else if ("*%/+-".indexOf(str.charAt(i)) >= 0)// 遇到运算符
            {
                if (top == -1)
                {// 若栈为空则直接入栈
                    top++;
                    opStack[top] = str.charAt(i);
                }
                else if ("*%/".indexOf(opStack[top]) >= 0)
                {// 当栈顶元素为高优先级运算符时,让栈顶元素出栈进入后缀表达式后,当前运算符再入栈
                    postQueue[j] = opStack[top] + "";
                    j++;
                    opStack[top] = str.charAt(i);
                }
                else
                {
                    top++;
                    opStack[top] = str.charAt(i);// 当前元素入栈
                }
            }
        }
        while (top != -1) {// 遍历结束后将栈中剩余元素依次出栈进入后缀表达式
            postQueue[j] = opStack[top] + "";
            j++;
            top--;
        }
        return postQueue;
    }

    //开方运算方法
    public String kfys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = Math.sqrt(a);
        result = String.valueOf(b);//将运算结果转换为string类型并赋给string类型的变量result
        return result;
    }

    //平方运算方法
    public String pfys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = Math.pow(a, 2);
        result = String.valueOf(b);
        return result;
    }

    // 计算后缀表达式，并返回最终结果
    public String Result(String[] str) {
        String[] Result = new String[100];// 顺序存储的栈，数据类型为字符串
        int Top = -1;// 静态指针Top
        for (int i = 0; str[i] != null; i++) {
            if ("+-*%/".indexOf(str[i]) < 0) {  //遇到数字，直接入栈
                Top++;
                Result[Top] = str[i];
            }
            if ("+-*%/".indexOf(str[i]) >= 0)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);// 顺序出栈两个数字字符串，并转换为double类型
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("*".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈

                }
                if ("/".indexOf(str[i]) >= 0)
                {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "error!";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
                if ("%".indexOf(str[i]) >= 0)
                {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "error!";
                        return s;
                    } else {
                        n = y % x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
            }
        }
        return Result[Top];// 返回最终结果
    }

    public static void main(String[] args) {
        Calculator a = new Calculator();
    }
}

参考文献
Java编写简单计算器–实现篇@阿雪狼
JAVA制作简易计算器@自娱自乐选手
java简单计算器的制作@星辰-大海
Java实现常规计算器（网格布局）@样young
java中indexof（）的几种用法@wust-lh
等等

xiaoxiaomi3
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
通信工程数电实验简易计算器
10-11
可以实现四位自然数的加减乘，结果在数码管显示，可以区分优先级和不区分优先级，溢出报错。
java简易计算器实验报告_Java 《Java 实现简单计算器》实验报告
weixin_34023073的博客
02-16 5348
15325592-d9e8874662abf194.png环境macOSjava 15Eclipse创建项目项目命名2020-10-19_5f8d56908a700.png如上图所示，打开 eclipse，安照流程File->New->Java Project创建一个新的项目，命令为calculator，点击 Finish 完成创建。新建类2020-10-19_5f8d5856e7c0...
实验一 简单计算器的实现
JUST192210713125的博客
11-25 1553
学习GUI图形界面的设计，Python Tinker或 Java Swing/Awt或C++ QT框架，创建交互友好的应用程序； 能通过界面按钮控件输入并实现算术表达式，输入的表达式即时在控件中显示，按下“=”按钮能实现运算，并将运算结果输出在控件中显示；要求能保存和浏览历史表达式的运算记录。 算术表达式求解，是指算术表达式中包括加、减、乘、除、括号等运算符，能求解包含括号的四则混合运算；并且能够检验表达式的合法性。 选做：①实现三角函数的运算、对数运算、指数运算、进制转换等； ...
C#程序设计实验——简易计算器
09-28
C#基础，C#程序设计实验——简易计算器实验报告+源代码 参照Windows自带的计算器工具，设计一个简易的计算器，可以实现基本的加减乘除功能
嵌入式实验报告-简易计算器.pdf
09-29
本实验报告的主要目的是设计和实现一个具有加减乘除功能的简易计算器，使用数码管和4X4矩阵式键盘来实现计算器的功能。下面是本实验报告的知识点总结： 1. 计算器的原理：计算器的原理是基于数码管和4X4矩阵式键盘...
java（实验）实现简易计算器（3）
01-15
这次实现的是学习中遇到的简易计算机（一共有三个文件，这是第三个） 界面设计有三个文本框，下面一行有四个按钮‘Plus’'Minus''Times''Divide'。通过输入要运算的两个数再按想要运算的运算符即可在第三个文本框...
数电实验二：简易计算器(设计报告).pdf
07-09
数电实验二：简易计算器(设计报告).pdf数电实验二：简易计算器(设计报告).pdf数电实验二：简易计算器(设计报告).pdf数电实验二：简易计算器(设计报告).pdf数电实验二：简易计算器(设计报告).pdf数电实验二：简易...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 316
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 602
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 539
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 404
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 830
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 197
Invalid keystore format 错误
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 107
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1142
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
eclipse插件开发中，获取一个java工程中的所有import的包名，并打印出来
liudong200618的博客
06-11 208
这段代码将遍历指定Java工程中的所有源代码文件，并打印出每个文件中的所有import语句。确保在开发Eclipse插件时，你的插件项目已经正确配置了对Eclipse JDT的依赖。
【使用ObjectSizeCalculator计算对象内存大小】
歪比巴卜
06-12 173
使用ObjectSizeCalculator计算对象内存大小的总结
Javascript写一个简易计算器实验
04-10
你可以尝试这样实现一个简易计算器：首先创建一个 HTML 文件，包含一个文本输入框和几个按钮，每个按钮分别代表加、减、乘、除和等于操作。然后，使用 JavaScript 监听每个按钮的点击事件，并根据用户的输入执行相应...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值