iis服务器助手广告广告
返回顶部
首页 > 资讯 > 后端开发 > Python >Java实现图形界面计算器
  • 440
分享到

Java实现图形界面计算器

2024-04-02 19:04:59 440人浏览 八月长安

Python 官方文档:入门教程 => 点击学习

摘要

本文实例为大家分享了Java实现图形界面计算器的具体代码,供大家参考,具体内容如下   代码: import javax.swing.*; import java.awt.*;

本文实例为大家分享了Java实现图形界面计算器的具体代码,供大家参考,具体内容如下

 

代码:


import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Stack;
 
public class Calculator extends JFrame implements ActionListener {
    private final String[] ButtonNames = {"(", ")", "←", "C", "7", "8", "9", "+", "4", "5",
            "6", "-", "1", "2", "3", "*", ".", "0", "=", "/"};
    private JTextField DisplayBox = new JTextField("0.0");
    private JTextField Cache = new JTextField("");
    private JButton[] Buttons = new JButton[ButtonNames.length];
 
    public Calculator() {
        super();
        setTitle("计算器");
        init();
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 400, 600);
        setResizable(false);                                 //窗口不可调整大小
        setVisible(true);
    }
 
    private void init() {                                    //完成布局以及定义监听器
        DisplayBox.setHorizontalAlignment(JTextField.RIGHT); //文本框右对齐
        DisplayBox.setFont(new Font("DIN", Font.BOLD, 30));   //DIN:一种数字常用字体
        Cache.setFont(new Font("DIN", Font.BOLD, 30));
 
        GridBagLayout gridBagLayout = new GridBagLayout();   //采取网格包布局
        GridBaGConstraints gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.fill = GridBagConstraints.BOTH;   //该方法是为了设置如果组件所在的区域比组件本身要大时的显示情况
        gridBagConstraints.weightx = 1;   //使组件的大小取得最大空间
        gridBagConstraints.weighty = 1;
        setLayout(gridBagLayout);
 
        gridBagConstraints.gridx = 0;    //缓存区起始位置为(0,0),横向占据4格,纵向1格
        gridBagConstraints.gridy = 0;
        gridBagConstraints.gridwidth = 4;
        gridBagConstraints.gridheight = 1;
        gridBagLayout.setConstraints(Cache, gridBagConstraints);
        this.add(Cache);
 
        gridBagConstraints.gridx = 0;    //文本框起始位置为(0,0),横向占据4格,纵向2格
        gridBagConstraints.gridy = 1;
        gridBagConstraints.gridwidth = 4;
        gridBagConstraints.gridheight = 2;
        gridBagLayout.setConstraints(DisplayBox, gridBagConstraints);
        this.add(DisplayBox);
 
        gridBagConstraints.gridy = 3;       //按钮起始位置为(0,3)
        gridBagConstraints.gridwidth = 1;   //每个按钮占据1格
        gridBagConstraints.gridheight = 1;
 
        for (int i = 0; i < ButtonNames.length; i++) {
            Buttons[i] = new JButton(ButtonNames[i]);
        }
        int n = 0;                           //记录每一行输出的按钮数,满4换行
        for (int i = 0; i < Buttons.length; i++) {
            gridBagLayout.setConstraints(Buttons[i], gridBagConstraints);
            this.add(Buttons[i]);
            n++;
            if (n == 4) {
                gridBagConstraints.gridx = 0;
                gridBagConstraints.gridy++;
                n = 0;
            } else {
                gridBagConstraints.gridx++;
            }
        }
 
        for (int i = 0; i < Buttons.length; i++) {     //事件监听器
            Buttons[i].addActionListener(this);
        }
    }
 
 
    @Override
    public void actionPerfORMed(ActionEvent e) {   //对事件的处理
        String str;
        String value = e.getActionCommand();    //获取按钮的值
        char v = value.charAt(0);
        switch (v) {
            case 'C':
                DisplayBox.setText("0.0");
                break;
            case '←':
                DeleteOne();
                break;
            case '=':
                String string = DisplayBox.getText();
                Cache.setText(string + "=");
                if (isTrue(string)) {            //若格式正确
                    str = retureResult();
                    DisplayBox.setText(str);
                } else {
                    DisplayBox.setText("输入格式不合法");
                }
                break;
            default:
                AddOne(value);
                break;
        }
    }
 
    private void DeleteOne() {       //删除一个字符
        String str;
        str = DisplayBox.getText();
        if (str.length() == 1) {
            DisplayBox.setText("0.0");
        } else if(!str.equals("0.0")) {
            str = str.substring(0, str.length() - 1);  //去掉最后一个元素
            DisplayBox.setText(str);
        }
    }
 
    private void AddOne(String value) {    //增加一个字符
        String str;
        str = DisplayBox.getText();
        if (str.equals("0.0")) {                       //第一次输入
            DisplayBox.setText(value);
        } else {
            str = str + value;
            DisplayBox.setText(str);
        }
    }
 
    private String retureResult() {                  //对输入的式子进行运算;基本方法:逆波兰法,中缀转后缀
        String string = DisplayBox.getText();
        String[] Midfix = breakDown(string);        //中缀表达式的数组
        String[] suffix = Conversion(Midfix);       //得到后缀表达式
        String result = Calculation(suffix);        //计算后缀表达式结果
        return result;
    }
 
    private String Calculation(String[] suffix) {
        Stack<String> stack = new Stack<>();
        String symbols = "+-*/";            //转换为后缀表达式的式子只会有 +-*/ 符号不会有 ()
        for (int i = 0; i < suffix.length; i++) {
            if (suffix[i] == null) {         //suffix后面可能出现null 故对其筛选不进行下列的操作
                continue;
            }
            if (symbols.indexOf(suffix[i]) >= 0) {       //为符号时进行运算
                double top1;
                double top2;
                double top;
                switch (suffix[i]) {
                    case "+":
                        top1 = Double.parseDouble(stack.pop());  //取栈顶将其转化为double
                        top2 = Double.parseDouble(stack.pop());
                        top = top2 + top1;
                        stack.push(String.valueOf(top));    //将top转化为String入栈
                        break;
                    case "-":
                        top1 = Double.parseDouble(stack.pop());
                        top2 = Double.parseDouble(stack.pop());
                        top = top2 - top1;
                        stack.push(String.valueOf(top));
                        break;
                    case "*":
                        top1 = Double.parseDouble(stack.pop());
                        top2 = Double.parseDouble(stack.pop());
                        top = top2 * top1;
                        stack.push(String.valueOf(top));
                        break;
                    case "/":
                        top1 = Double.parseDouble(stack.pop());
                        top2 = Double.parseDouble(stack.pop());
                        if (top1 == 0) {
                            return "运算过程中除数出现0";
                        }
                        top = top2 / top1;
                        stack.push(String.valueOf(top));
                        break;
                }
            } else {        //为数字直接入栈
                stack.push(suffix[i]);
            }
        }
        String result = stack.pop();
        return result;
    }
 
    private String[] breakDown(String string) {      //将(2+3.14)+9分解成 ( 2 + 3.14 ) + 9便于后续计算
        String[] split = string.split("");
        String DigitString = "0123456789.";
        String afterSplit = "";
        for (int i = 0; i < split.length; i++) {    //将 2+3.14 变成 2,+,3.14 便于拆分
            if (DigitString.indexOf(split[i]) >= 0) {
                afterSplit = afterSplit + split[i];
            } else if(afterSplit.equals("") && DigitString.indexOf(split[i]) < 0) { //第一个为符号时只在后面加。
                afterSplit = afterSplit + split[i] + ",";
            } else {                                //为 () 或 =-*/ 在其两侧加上 ,
                afterSplit = afterSplit + "," + split[i] + ",";
            }
        }
        afterSplit = afterSplit.replace(",,", ",");  //避免(2+3)+2产生……3,),,+,2
        split = afterSplit.split(",");  //产生的字符串数组中只会含+-*/()整数和小数
        return split;
    }
 
    private String[] Conversion(String[] strings) {     //中缀转后缀
        String[] suffix = new String[strings.length];    //后缀表达式
        int n = 0;                                       //suffix的下标
        Stack<String> stack = new Stack<>();
        String first = "*/";
        String symbols = "+-*/()";
        for (int i = 0; i < strings.length; i++) {
            if(symbols.indexOf(strings[i]) >= 0) {  //为符号时
                if (stack.empty()) {
                    stack.push(strings[i]);
                } else {            //栈不为空
                    if(first.indexOf(strings[i]) >= 0 || strings[i].equals("(")) {   //为 +/( 直接入栈
                        stack.push(strings[i]);
                    }  else if(strings[i].equals(")")) {
                        String top = stack.peek();
                        while(!top.equals("(")) {
                            top = stack.pop();
                            suffix[n] = top;
                            n++;
                            top = stack.peek();
                        }
                        stack.pop();    // ( 出栈
                    } else {    //符号为 +-
                        if(first.indexOf(stack.peek()) < 0) { //当栈顶不为为 */ 直接入栈
                            stack.push(strings[i]);
                        } else {
                            while (!stack.empty() && first.indexOf(stack.peek()) >= 0)
                            //栈顶运算符先于当前运算符时,出栈到栈顶运算符低于或栈为空为止
                            {
                                String s = stack.pop();
                                suffix[n] = s;
                                n++;
                            }
                            stack.push(strings[i]); //当前运算符入栈
                        }
                    }
                }
            } else {    //为数字直接成为后缀一部分
                suffix[n] = strings[i];
                n++;
            }
        }
        while (!stack.empty()) {        //清除栈内剩余符号
            String s = stack.pop();
            suffix[n] = s;
            n++;
        }
        return suffix;
    }
 
    private boolean isTrue(String str) {
        if (!BracketMatching(str)) {      //括号匹配
            return false;
        }
        if (!OperatorIsTrue(str)) {      //符号格式正确
            return false;
        }
        return true;
    }
 
    private boolean OperatorIsTrue(String string) { //运算数数量 = 运算符号数+1
        String[] split = breakDown(string);
        String symblos = "+-*/";
        String bracket = "()";
        int NumberOfDigits = 0;
        int NumberOfSymblos = 0;
        for (int i = 0; i < split.length; i++) {
            if(symblos.indexOf(split[i]) >= 0) {
                NumberOfSymblos++;
            } else if(bracket.indexOf(split[i]) < 0) { //不是括号 不是运算符一定为运算数
                NumberOfDigits++;
            }
        }
        if (NumberOfDigits != NumberOfSymblos + 1) {
            return false;
        }
        return true;
    }
 
    private boolean BracketMatching(String string) {    //判断括号是否匹配,否则报错
        char[] split = string.toCharArray();
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < split.length; i++) {
            if (split[i] == '(') {
                stack.push(split[i]);
            } else if (!stack.empty() && split[i] == ')') {
                stack.pop();
            } else if (stack.empty() && split[i] == ')') {
                return false;
            }
        }
        if (!stack.empty()) {
            return false;
        }
        return true;
    }
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
    }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持编程网。

--结束END--

本文标题: Java实现图形界面计算器

本文链接: https://www.lsjlt.com/news/157978.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • Java实现图形界面计算器
    本文实例为大家分享了Java实现图形界面计算器的具体代码,供大家参考,具体内容如下   代码: import javax.swing.*; import java.awt.*; ...
    99+
    2022-11-12
  • Java实现简单图形界面计算器
    前言 因为这两天我们的Java实验课程需要做两个小的图形化界面,其中就有一个图形界面的计算器,所以稍微花了点时间做了一个,同时复习了一下Java的基础内容和GUI编程。因为代码中的注...
    99+
    2022-11-13
  • Java怎么实现图形界面计算器
    这篇文章主要介绍“Java怎么实现图形界面计算器”,在日常操作中,相信很多人在Java怎么实现图形界面计算器问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”Java怎么实现图形界面计算器”的疑惑有所帮助!接下来...
    99+
    2023-06-25
  • java图形界面之加法计算器
    JAVA用于开发图形界面应用的 SWING 组件包功能强大,使用方便。接下来我们就使用其写一个简单的图形界面小程序:加法计算器。 第一步: 首先得构思,我们要做什么。加法计算器的话,...
    99+
    2022-11-13
  • Python实现图形用户界面计算器
    本文实例为大家分享了Python实现图形用户界面计算器的具体代码,供大家参考,具体内容如下 简易用户图形界面计算器设计思路: 简易图形用户界面计算器的界面和功能设计如下: (1)第...
    99+
    2022-11-11
  • java图形界面之怎么实现加法计算器
    这篇文章主要介绍“java图形界面之怎么实现加法计算器”的相关知识,小编通过实际案例向大家展示操作过程,操作方法简单快捷,实用性强,希望这篇“java图形界面之怎么实现加法计算器”文章能帮助大家解决问题。第一步:首先得构思,我们要做什么。加...
    99+
    2023-06-30
  • Java图形化界面编程实现简单计算器
    1.简单计算器 使用AWT编程,FrameNORTH区域放置TextField组件,将指定为4行5列GridLayout布局管理器的Panel放置于Frame中部区域,其中填充操作符...
    99+
    2022-11-12
  • 如何使用Java图形化界面编程实现简单计算器
    这篇文章主要为大家展示了“如何使用Java图形化界面编程实现简单计算器”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“如何使用Java图形化界面编程实现简单计算器”这篇文章吧。1.简单计算器使用A...
    99+
    2023-06-22
  • Java实现Windows计算器界面
    前一段时间在学校简单的学习了Java,对Java这门我第一次接触的面向对象语言有了一定的了解。 一直没时间整理写的东西,今天打算整理下上传下。 Java相对于C来说比较方便的就是用来...
    99+
    2022-11-12
  • JavaGUI图形界面开发实现小型计算器流程详解
    目录一、设计目标二、界面设计三、功能实现四、全部代码五、功能测试六、小结一、设计目标 (1)主要功能:实现简单的加、减、乘、除等双目运算,和开平方、百分数等单目运算 (2)辅助功能:...
    99+
    2022-11-13
    Java GUI 图形界面 计算器 Java 计算器
  • java实现简易的计算器界面
    如何用java写一个简易的计算器界面,供大家参考,具体内容如下 前言(与本节重点无关可以忽视) 最近了解了一些界面窗口知识,在老师一步步的悉心教导下我却又一次地走向了迷茫&mdash...
    99+
    2022-11-13
  • Java实现图形化界面的日历
    本文实例为大家分享了Java实现图形化界面日历的具体代码,供大家参考,具体内容如下 此程序主要功能实现了可以根据用户选择的年月日来定位日期,日期的旁边用#加以标注 主界面如下: 代...
    99+
    2022-11-13
  • java swing怎么实现简单计算器界面
    这篇文章主要介绍“java swing怎么实现简单计算器界面”,在日常操作中,相信很多人在java swing怎么实现简单计算器界面问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”java&...
    99+
    2023-06-30
  • Java程序图形用户界面设计之容器JFrame
    目录基本容器JFrameJFrame类的常用操作方法创建窗体Java程序设计 图形用户界面 【二】 基本容器JFrame JFrame类的常用操作方法 方法作用public JFra...
    99+
    2022-11-13
  • 使用PyQt5设计GUI实现程序图形界面设计
    目录一、熟悉designer——设计界面的神器1.首先打开designer。2.创建窗口3.熟悉各部功能区域二、设计自己的第一个GUI。1.在designer中拖动控件来完善窗口程序...
    99+
    2022-11-12
  • Java实现带图形界面的聊天程序
    本文实例为大家分享了Java实现带图形界面聊天程序的具体代码,供大家参考,具体内容如下 ServerDemo01.java import javax.swing.*; import ...
    99+
    2022-11-13
  • javaswing实现简单计算器界面
    本文实例为大家分享了java swing实现简单计算器界面的具体代码,供大家参考,具体内容如下 已经学习了一部分的swing知识,现在综合运用里面的部分知识来实现一个计算器的界面。 ...
    99+
    2022-11-13
  • Java图形化界面设计之容器的示例分析
    这篇文章主要为大家展示了“Java图形化界面设计之容器的示例分析”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“Java图形化界面设计之容器的示例分析”这篇文章吧。Java图形化界面设计——容器(...
    99+
    2023-05-30
    java
  • c++如何实现图形化界面
    C++本身是一种面向对象的编程语言,不直接提供图形化界面的功能。但是可以通过使用第三方库或者框架来实现图形化界面。以下是几种常见的C...
    99+
    2023-09-14
    c++
  • C#实现图形界面的时钟
    本文实例为大家分享了C#实现图形界面的时钟的具体代码,供大家参考,具体内容如下 秒针有跳跃两个格子问题,主要是算法耗时没考虑在TimeTicker的触发事件内,导致程序运行有延迟。 ...
    99+
    2022-11-13
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作