Java——一个简单的计算器程序

news2024/11/18 17:38:24

 

该代码是一个简单的计算器程序，使用了Java的图形化界面库Swing。具体分析如下：

  1. 导入必要的类和包：

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

    代码中导入了用于创建图形界面的类和接口，以及其他必要的类。

  2. 定义Calculator类：

    public class Calculator extends JFrame implements ActionListener {
    // 类的成员变量和组件的定义
}

    代码中定义了一个名为Calculator的类，继承了JFrame类，并实现了ActionListener接口。Calculator类是程序的主类，并包含了图形界面相关的成员变量和组件的定义。

  3. 初始化界面和组件：

    public Calculator() {
    // 界面和组件的初始化代码
}

    在Calculator类的构造方法中，定义了计算器的界面布局，并创建了相关的各种组件，如按钮、文本域等，并设置它们的大小、位置和属性。

  4. 处理按钮事件：

    public void actionPerformed(ActionEvent e) {
    // 按钮事件的处理代码
}

    Calculator类实现了ActionListener接口，重写了接口中的actionPerformed方法，用于处理按钮的点击事件。根据不同按钮的标签，在该方法中执行相应的操作，如进行计算、清空、显示历史记录等。

以上就是该代码的分析。它实现了一个简单的图形化计算器界面，并提供了一些基本的计算功能和历史记录功能。用户可以通过界面上的按钮进行输入和操作，并在文本域中显示结果和历史记录。

package ch5;

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

import javax.swing.*;

//Calculator类，继承JFrame框架，实现事件监听器接口
public class Calculator extends JFrame implements ActionListener {
    private final String[] KEYS = { "7", "8", "9", "AC", "4", "5", "6", "-", "1", "2", "3", "+", "0", "e", "pi", "/", "sqrt",
            "%", "x*x", "*", "(", ")", ".", "=" };
    private JButton keys[] = new JButton[KEYS.length];
    private JTextArea resultText = new JTextArea("0.0");// 文本域组件TextArea可容纳多行文本；文本框内容初始值设为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 JScrollPane gdt3=new JScrollPane(History);//给历史记录文本域新建一个水平滚动滑条
    private JLabel label = new JLabel("历史记录");
    private String b = "";

    // 构造方法
    public Calculator() {
        super("Caculator");//“超”关键字，表示调用父类的构造函数，
        resultText.setBounds(20, 18, 255, 115);// 设置文本框大小
        resultText.setAlignmentX(RIGHT_ALIGNMENT);// 文本框内容右对齐
        resultText.setEditable(false);// 文本框不允许修改结果
        History.setBounds(290, 40, 250,370);// 设置文本框大小
        History.setAlignmentX(LEFT_ALIGNMENT);// 文本框内容右对齐
        History.setEditable(false);// 文本框不允许修改结果
        label.setBounds(300, 15, 100, 20);//设置标签位置及大小
        jp2.setBounds(290,40,250,370);//设置面板窗口位置及大小
        jp2.setLayout(new GridLayout());
        JPanel jp1 = new JPanel();
        jp1.setBounds(20,18,255,115);//设置面板窗口位置及大小
        jp1.setLayout(new GridLayout());
        resultText.setLineWrap(true);// 激活自动换行功能
        resultText.setWrapStyleWord(true);// 激活断行不断字功能
        resultText.setSelectedTextColor(Color.RED);
        History.setLineWrap(true);//自动换行
        History.setWrapStyleWord(true);
        History.setSelectedTextColor(Color.blue);
        gdt1.setViewportView(resultText);//使滚动条显示出来
        gdt2.setViewportView(History);
        gdt1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
        gdt2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
        gdt2.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);//设置让水平滚动条一直显示
        jp1.add(gdt1);//将滚动条添加入面板窗口中
        jp2.add(gdt2);
        this.add(jp1);//将面板添加到总窗体中
        this.add(jp2);//将面板添加到总窗体中
        this.setLayout(null);
        this.add(label);// 新建“历史记录”标签
        //this.add(resultText);// 新建文本框，该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示或者发生覆盖
        //this.add(History);// 新建历史记录文本框，该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示

        // 放置按钮
        int x = 20, y = 150;
        for (int i = 0; i < KEYS.length; i++)
        {
            keys[i] = new JButton();
            keys[i].setText(KEYS[i]);
            keys[i].setBounds(x, y, 60, 40);
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                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.setDefaultCloseOperation(EXIT_ON_CLOSE);
        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");//更新文本域的显示，显示初始值;
        }
        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
        {
            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++)// 遍历中缀表达式
        // 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();
    }
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/946539.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java 中数据结构HashMap的用法

Java 中数据结构HashMap的用法

Java HashMap HashMap 是一个散列表&#xff0c;它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口&#xff0c;根据键的 HashCode 值存储数据&#xff0c;具有很快的访问速度&#xff0c;最多允许一条记录的键为 null&#xff0c;不支持线程同步。 HashMap 是…
阅读更多...
打通数字化供需“堵点”，828 B2B企业节推出企业应用一站购平台

打通数字化供需“堵点”，828 B2B企业节推出企业应用一站购平台

当前&#xff0c;数字技术与实体经济深度融合&#xff0c;为千行百业注入新动力、拓展新空间。数据显示&#xff0c;2022年中国数字经济规模超过50万亿&#xff0c;占GDP比重超过40%&#xff0c;继续保持在10%的高位增长速度&#xff0c;成为稳定经济增长的关键动力。 为加速企…
阅读更多...
智慧校园用电安全解决方案

智慧校园用电安全解决方案

随着科技的不断发展&#xff0c;智慧校园建设逐渐成为了教育行业的一大趋势。在这个过程中&#xff0c;电力系统作为校园基础设施的重要组成部分&#xff0c;其安全、稳定、高效的运行显得尤为重要。下面小编来为大家介绍下智慧校园用电安全解决方案吧! 一、智慧校园电力系统现…
阅读更多...
腾讯云学生服务器优惠价格申请教程

腾讯云学生服务器优惠价格申请教程

腾讯云学生服务器优惠价格申请教程&#xff0c;腾讯云学生服务器活动&#xff1a;轻量应用服务器2核2G学生价30元3个月、58元6个月、112元一年&#xff0c;轻量应用服务器4核8G配置191.1元3个月、352.8元6个月、646.8元一年&#xff0c;CVM云服务器2核4G配置842.4元一年&#x…
阅读更多...
SimpleMind Pro(电脑版思维导图软件)中文版

SimpleMind Pro(电脑版思维导图软件)中文版

Simplemind pro是一款极具创意和高效的可视化思维导图工具&#xff0c;它的设计和功能让它在众多思维导图软件中脱颖而出。本文将向您介绍Simplemind pro的特点、使用方法、适用场景以及与其他思维导图软件的比较&#xff0c;帮助您更好地了解Simplemind pro的优势和使用价值。…
阅读更多...
文旅虚拟人主播智能讲解员能与人实时对话

文旅虚拟人主播智能讲解员能与人实时对话

元宇宙作为虚拟世界和现实社会交互的重要平台&#xff0c;是数字经济的表现形态之一&#xff0c;在文化和旅游领域拥有广阔的应用空间&#xff0c;也是当下该领域的热门赛道。 众多文旅行业从业者纷纷以“文化科技旅游”的方式&#xff0c;努力探索合适形态的应用场景和商业机会…
阅读更多...
EMQX启用双向SSL/TLS安全连接以及java连接

EMQX启用双向SSL/TLS安全连接以及java连接

作为基于现代密码学公钥算法的安全协议&#xff0c;TLS/SSL 能在计算机通讯网络上保证传输安全&#xff0c;EMQX 内置对 TLS/SSL 的支持&#xff0c;包括支持单/双向认证、X.509 证书、负载均衡 SSL 等多种安全认证。你可以为 EMQX 支持的所有协议启用 SSL/TLS&#xff0c;也可…
阅读更多...
一文2500字使用Python进行GRPC和Dubbo协议的高级测试

一文2500字使用Python进行GRPC和Dubbo协议的高级测试

01、GRPC测试 GRPC&#xff08;Google Remote Procedure Call&#xff09;是一种高性能、开源的远程过程调用&#xff08;RPC&#xff09;框架&#xff0c;由 Google开发并基于Protocol Buffers&#xff08;protobuf&#xff09;进行通信。它使用了HTTP/2协议作为传输层&#x…
阅读更多...
hadoop学习：mapreduce入门案例二：统计学生成绩

hadoop学习：mapreduce入门案例二：统计学生成绩

这里相较于 wordcount&#xff0c;新的知识点在于学生实体类的编写以及使用 数据信息&#xff1a; 1. Student 实体类 import org.apache.hadoop.io.WritableComparable;import java.io.DataInput; import java.io.DataOutput; import java.io.IOException;public class Stude…
阅读更多...
移植使用tslib 库

移植使用tslib 库

目录 tslib 简介tslib 移植下载tslib 源码编译tslib 源码tslib 安装目录下的文件夹介绍在开发板上测试tslib tslib 库函数介绍打开触摸屏设备配置触摸屏设备读取触摸屏数据 基于tslib 编写触摸屏应用程序单点触摸应用程序多点触摸应用程序 上一章我们学习了如何编写触摸屏应用程…
阅读更多...
pyechart笔记：opts.AxisOpts

pyechart笔记：opts.AxisOpts

定制化图表的轴线&#xff08;x轴和y轴&#xff09;的样式和设置 0 不设置坐标轴 c1(Bar().add_xaxis([力量,智力,敏捷]).add_yaxis(全能骑士,# 系列名称&#xff0c;用于 tooltip 的显示&#xff0c;legend 的图例筛选。[429,321,296],#系列数据).add_yaxis(猴子,[352,236,4…
阅读更多...
常微分方程的龙格库塔显式与隐式解法

常微分方程的龙格库塔显式与隐式解法

好习惯&#xff0c;讲问题之前先来介绍一下最近生活状况。 得到了 熟人的 熟人认证 很好 很荣幸了 属于是先上全部代码与效果图 import matplotlib.pyplot as plt import numpy as np from scipy.optimize import fsolveclass odesolver():def __init__(self, f, X_start0, X_…
阅读更多...
树与图c++

树与图c++

1.树 前言 本文主要介绍的数据结构之树型结构的相关知识&#xff0c;树型数据结构是面试官面试的时候非常喜欢考的一种数据结构&#xff0c;树形结构的遍历也是大厂笔试非常喜欢设置的考点&#xff0c;这些内容都会在本篇文章中进行详细的介绍&#xff0c;并且还会介绍一些常…
阅读更多...
Doris架构中包含哪些技术？

Doris架构中包含哪些技术？

Doris主要整合了Google Mesa(数据模型)&#xff0c;Apache Impala(MPP Query Engine)和Apache ORCFile (存储格式&#xff0c;编码和压缩)的技术。 为什么要将这三种技术整合? Mesa可以满足我们许多存储需求的需求&#xff0c;但是Mesa本身不提供SQL查询引擎。 Impala是一个…
阅读更多...
【IEEE会议】第六届IEEE机械工程与智能制造国际会议（WCMEIM 2023）

【IEEE会议】第六届IEEE机械工程与智能制造国际会议（WCMEIM 2023）

2023年第六届IEEE机械工程与智能制造国际会议&#xff08;WCMEIM 2023&#xff09; 2023 6th World Conference on Mechanical Engineering and Intelligent Manufacturing 坚定不移加快发展智能制造&#xff0c;推进信息化和工业化深度融合&#xff0c;实现制造业质量变革、…
阅读更多...
uniapp 配置小程序分包

uniapp 配置小程序分包

分包可以减少小程序首次启动时的加载时间 分包页面&#xff08;例如&#xff1a;商品详情页、商品列表页&#xff09;。在 uni-app 项目中&#xff0c;配置分包的步骤如下&#xff1a; 1、右键点击根目录&#xff0c;新建&#xff0c;点击创建分包的根目录&#xff0c;命名为 …
阅读更多...
YOLO目标检测——Kylberg纹理数据集下载分享

YOLO目标检测——Kylberg纹理数据集下载分享

Kylberg纹理数据集共同4640图片&#xff0c;可应用于&#xff1a;纹理分类与识别、材料识别与质检、医学图像分析、地质勘探与地表覆盖分类等等 数据集点击下载&#xff1a;YOLO目标检测Kylberg纹理数据集4640图片.rar
阅读更多...
《开发实战》11 | 空值处理：分不清楚的null和恼人的空指针

《开发实战》11 | 空值处理：分不清楚的null和恼人的空指针

11 | 空值处理&#xff1a;分不清楚的null和恼人的空指针 修复和定位恼人的空指针问题 NullPointerException 是 Java 代码中最常见的异常&#xff0c;最可能出现的场景归为以下5 种&#xff1a; 参数值是 Integer 等包装类型&#xff0c;使用时因为自动拆箱出现了空指针异常…
阅读更多...
02调制+滤波器+冲激函数的傅立叶变换

02调制+滤波器+冲激函数的傅立叶变换

目录 一、调制方式 1.1 什么是调制&#xff1f; 1.2 为什么要调制&#xff1f; 1.3 如何调制&#xff1f; 1.4 调制包含的信号类型&#xff1f; 1. 消息信号 2. 载波信号 3. 调制信号 1.5 调制类型&#xff1f; 1. 调幅 2. 调频 3. 调相 4. 模拟脉冲调制 5. 脉冲…
阅读更多...
07:STM32----ADC模数转化器

07:STM32----ADC模数转化器

目录 1:简历 2:逐次逼近型ADC 3:ADC基本结构 4:输入通道 5:规则组的4种转换模式 1:单次转化,非扫描模式 2:连续转化,非扫描模式 3:单次转化,扫描模式 4:单次转化,扫描模式 6:触发控制 7:数据对齐 8:转化时间 9:校准 10:ADC的硬件电路 A: AD单通道 1:连接图 2:函…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023