Java实现四则运算计算器

最新推荐文章于 2021-02-26 02:12:24 发布
最新推荐文章于 2021-02-26 02:12:24 发布
阅读量4.4k 收藏 42
点赞数 4
分类专栏： 简易项目开发 文章标签： java 计算器 四则运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUMTLZ/article/details/79181463
版权

Java实现四则运算计算器，支持带有括号的四则运算，以及求余，取倒数，开平方。原理比较简单，界面可能比较粗糙，读者仅供参考，可以自行进行修改。
这里写图片描述

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Stack;
import javax.swing.*;
import javax.xml.soap.Text;
public class Calculator extends JFrame{
       Stack<Character> priStack=new Stack<Character>();
       Stack<Double> numStack=new Stack<Double>();
        public  Calculator() {
            Container c=getContentPane();
            Font font = new Font("宋体",Font.BOLD,15); 
            this.setLayout(new GridLayout(4,1));
            JTextField jt=new JTextField("0");
            JTextField jt1=new JTextField("");
            jt.setFont(font);jt1.setFont(font);
            jt1.setHorizontalAlignment(JTextField.RIGHT);
            jt.setHorizontalAlignment(JTextField.RIGHT);
            JButton  data0=new JButton("0");
            JButton  data1=new JButton("1");
            JButton  data2=new JButton("2");
            JButton  data3=new JButton("3");
            JButton  data4=new JButton("4");
            JButton  data5=new JButton("5");
            JButton  data6=new JButton("6");
            JButton  data7=new JButton("7");
            JButton  data8=new JButton("8");
            JButton  data9=new JButton("9");
            JButton  left=new JButton("(");
            JButton  l1=new JButton("1/x");
            JButton  l2=new JButton(" ");
            JButton  l3=new JButton(" ");
            JButton  right=new JButton(")");
            JButton  point=new JButton(".");
            JButton  sqrt1=new JButton("sqrt");
            JButton  mod=new JButton("%");
            JButton  puls=new JButton("+");
            JButton  minus=new JButton("-");
            JButton  equ=new JButton("=");
            JButton  mul=new JButton("*");
            JButton  dvd=new JButton("/");
            JButton  DEC=new JButton("清零");
            JButton  back=new JButton("退格");
            JPanel jp=new JPanel();
            jp.setLayout(new GridLayout(3,5,5,5));
            jp.add(data7);jp.add(data8);
            jp.add(data9);jp.add(puls);jp.add(back);
            jp.add(data4);
            jp.add(data5);jp.add(data6);
            jp.add(minus);jp.add(DEC); jp.add(data1);
            jp.add(data2);jp.add(data3);
            jp.add(mul);jp.add(sqrt1);
            JPanel jpp=new JPanel();
            jpp.setLayout(new GridLayout(2,5,5,5));
            jpp.add(point);jpp.add(equ);jpp.add(data0);
            jpp.add(dvd);jpp.add(mod);
            jpp.add(left);jpp.add(right);
            jpp.add(l1); jpp.add(l2); jpp.add(l3);
            c.add(jt);c.add(jt1);c.add(jp);c.add(jpp);
            this.setSize(400,500);
            this.setTitle("计算器");
            this.setVisible(true);
            this.setResizable(false);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            sqrt1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0)
                {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                    }else {
                        String str=jt.getText();
                        double t1=Double.parseDouble(str);
                        t1=Math.sqrt(t1);
                        str=String.valueOf(t1);
                        jt1.setText(str);
                    }
                }
                });
            l1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0)
                {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                    }else {
                        String str=jt.getText();
                        double t1=Double.parseDouble(str);
                        t1=1/t1;
                        str=String.valueOf(t1);
                        jt1.setText(str);
                    }
                }
                });
            mod.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"%");
                    }
                }

            });
            data0.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"0");
                    }
                }
               });
            data1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("1");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"1");
                    }
                }
               });
            data2.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("2");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"2");
                    }
                }
               });
            data3.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("3");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"3");
                    }
                }
               });
            data4.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("4");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"4");
                    }
                }
               });
            data5.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("5");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"5");
                    }
                }
               });
            data6.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("6");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"6");
                    }
                }
               });
            data7.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("7");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"7");
                    }
                }
               });
            data8.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("8");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"8");
                    }
                }
               });
            data9.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("9");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"9");
                    }
                }
               });
            point.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText(".");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+".");
                    }
                }
               });
            puls.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("+");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"+");
                    }
                }
               });
            minus.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("-");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"-");
                    }
                }
               });
            left.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("(");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"(");
                    }
                }
               });
            right.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText(")");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+")");
                    }
                }
               });
            mul.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("*");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"*");
                    }
                }
               });

            dvd.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    if(jt.getText().equals("0")) {
                        jt.requestFocus();
                        jt.setText("");
                        jt.setText("/");
                    }else {
                        String str=jt.getText();
                        jt.setText(str+"/");
                    }
                }
               });
            //清零
            DEC.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    jt.setText("0");
                    jt1.setText("");
                }
            });
            equ.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {              
                    String str=jt.getText();
                    str=str+"#";
                    String temp;
                    StringBuffer tempNum = new StringBuffer();     
                    StringBuffer string = new StringBuffer().append(str);  
                    while (string.length() != 0) {      
                        temp = string.substring(0, 1);      
                        string.delete(0, 1);         
                        if (!isNum(temp)) {        
                            if (!"".equals(tempNum.toString())) {       
                                double num =Double.parseDouble(tempNum.toString());      
                                numStack.push(num);  
                                tempNum.delete(0, tempNum.length());      
                            }          
                            while (!compare(temp.charAt(0)) && (!priStack.empty())) {   
                                double a = (double) numStack.pop();      
                                double b = (double) numStack.pop();
                                char ope = priStack.pop();      
                                double result = 0;
                                switch (ope) {      
                                case '+':      
                                    BigDecimal a1=new BigDecimal(Double.toString(a));
                                    BigDecimal b1=new BigDecimal(Double.toString(b));
                                    result =b1.add(a1).doubleValue();      
                                    numStack.push(result);      
                                    break;      
                                case '-': 
                                    BigDecimal a111=new BigDecimal(Double.toString(a));
                                    BigDecimal b111=new BigDecimal(Double.toString(b));
                                    result =b111.subtract(a111).doubleValue();                                 
                                    numStack.push(result);      
                                    break;      
                                case '*':     
                                    BigDecimal a11=new BigDecimal(Double.toString(a));
                                    BigDecimal b11=new BigDecimal(Double.toString(b));
                                    result =b11.multiply(a11).doubleValue();     
                                    numStack.push(result);      
                                    break;      
                                case '/':  
                                    BigDecimal a1111=new BigDecimal(Double.toString(a));
                                    BigDecimal b1111=new BigDecimal(Double.toString(b));
                                    result=b1111.divide(a1111).doubleValue();
                                    numStack.push(result);      
                                    break; 
                                case '%':      
                                    result = b %a;
                                    numStack.push(result);      
                                    break;
                                }      

                            }      
                            if (temp.charAt(0) != '#') {      
                                priStack.push(new Character(temp.charAt(0)));      
                                if (temp.charAt(0) == ')') {  
                                    priStack.pop();      
                                    priStack.pop();      
                                }      
                            }      
                        } else          
                            tempNum = tempNum.append(temp);     
                    }      
                    double t=numStack.pop();
                    jt1.setText(String.valueOf(t));
                }   
                } );
            back.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent arg0) {
                    String text=jt.getText();
                    int i=text.length();
                    if(i>0) {
                        text=text.substring(0,i-1);
                        if(text.length()==0) jt.setText("0");
                        else jt.setText(text);
                    }
                }
            });

       }
private boolean isNum(String temp) {      
    return temp.matches("[0,1,2,3,4,5,6,7,8,9,.]");      
}       
private boolean compare(char str) {      
    if (priStack.empty()) {        
        return true;      
    }      
    char last = (char) priStack.lastElement();         
    if (last == '(') {      
        return true;      
    }      
    switch (str) {      
    case '#':      
        return false; 
    case '(':        
        return true;      
    case ')':          
        return false;      
    case '*': {        
        if (last == '+' || last == '-')      
            return true;      
        else      
            return false;      
    }      
    case '/': {      
        if (last == '+' || last == '-')      
            return true;      
        else      
            return false;      
    } 
    case '%': {      
        if (last == '+' || last == '-')      
            return true;      
        else      
            return false;      
    }       
    case '+':      
        return false;      
    case '-':      
        return false;      
    }      
    return true;      
}      
  public static void main(String []args) {
      Calculator c=new Calculator();

  }
}
刺破黎明
关注
  • 4
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用java语言实现的四则运算计算器
04-11
这是一款用java语言实现的四则运算计算器，支持正负数、小数点。
java实现四则运算
08-30
java实现四则运算，将中缀表达式变成后缀表达式，使用栈来做最后的运算
3.20 接口--四则计算器 (10分)
ihopeyousuccess的博客
12-17 5119
20 接口–四则计算器 (10分) 利用接口做参数，写个计算器，能完成加减乘除运算。 定义一个接口ICompute含有一个方法int computer(int n, int m)。 定义Add类实现接口ICompute，实现computer方法，求m，n之和 定义Sub类实现接口ICompute，实现computer方法，求n-m之差 定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。 输入格式
java四则运算
weixin_30352645的博客
09-19 222
一家软件公司程序员二柱的小孩上了小学二年级，老师让家长每天出30道四则运算题目给小学生做。 二柱子那样，花二十分钟写一个能自动生成30道小学四则运算题目的 “软件” 课堂测试2： （1）题目避免重复； （2）可定制（数量/打印方式）； 设计思路：利用随机函数random（）生成随机数，创建数组，把生成的四则算数式子存入数组，然后比较，避免重复。 package jish...
java四则运算计算器
03-11
本程序是一个计算四则运算表达式的程序，它有比图形计算器效率高，使用起来就像使用linux shell一样方便，支持计算历史清空等优点，使用一个bat文件启动程序，操作界面是一个cmd命令窗口，希望大家会喜欢，如果有不足请大家多多指正
基于java的四则运算计算器设计与实现毕业设计任务书.docx
07-14
基于java的四则运算计算器设计与实现毕业设计任务书.docx基于java的四则运算计算器设计与实现毕业设计任务书.docx基于java的四则运算计算器设计与实现毕业设计任务书.docx基于java的四则运算计算器设计与实现毕业...
java简易计算器（四则运算、三角函数、实现优先级）
02-27
Java简易计算器是一个基于Java编程语言实现的计算工具，它不仅支持基本的四则运算，还具备处理三角函数的能力，并且已经实现了运算的优先级规则。这个项目的核心是将用户输入的中缀表达式（常见的数学表达式形式）...
Java 四则运算计算器
最新发布
08-12
利用JavaSwing实现的简单四则运算计算器
基于java的四则运算计算器设计与实现毕业设计任务书.pdf
07-14
【基于Java的四则运算计算器设计与实现】的毕业设计是一项综合性的项目，旨在通过创建一个GUI界面的计算器，让学生深入理解和应用Java编程语言的面向对象特性。此设计任务不仅涵盖了基本的四则运算，还涉及到更复杂...
java计算四则运算_JAVA编程——计算器四则运算
weixin_28703489的博客
02-26 214
import java.util.Scanner;interface Operation{double getResult(double numA,double numB);}class Plus implements Operation{public double getResult(double numA,double numB){return numA+numB;}}class Minus ...
Java版计算器支持四则混合运算.+-*/()
06-08
Java版计算器 支持四则混合运算 +-*/() 支持小数点 都是在在网上收集的计算器，然后稍加改动。亲测全部可运行。
Java综合程序设计——计算器（实现运算符优先级的四则混合运算）
06-19
一个计算器，有多种功能，如取对数、求平方根。最重要的是利用堆栈算法实现运算符优先级。
四则运算JAVA程序
11-15
我在无聊的时候写的，简单的JAVA程序。请大家指点
Java四则运算
10-07
java 实验报告用四则运算加减乘除用java编写的简易计算器实验报告 实现计算器的加、减、乘、除等基本功能，参考Windows计算器增加多种功能，并处理异常。
java实现简易计算器功能（一次四则运算）
临水一照花
12-03 1312
java实现简易计算器功能（一次四则运算） 界面设计，监听器，四则运算 //2020年11月27日 临水一照花 import java.awt.*; import javax.swing.*; import java.awt.event.*; public class Computer { JFrame m_mainF; Container m_cPane; JTextArea m_tA; JPanel m_panelA; JButton m_btn1,m_btn2,m_btn3,
四则运算计算器
KEN的程序员之路
12-01 1043
/* 这是我做的计算器涵数,computer() 作者QQ:328266362 */ #include #include #include double add(double cd[],char cf[],int cn);main(){ char cmp[255]; double total; char x; int n=0; printf("input to compuer:");
栈的应用--计算器实现四则运算
華仔的博客
12-03 1550
学习一个知识点并不是那么难，而要运用所学的知识点去实现一个功能或者做一个项目却总不是那么简单。就像这个标题，如何用栈来做出一个计算器呢？ 我们先来思考一番，比如有个式子：9 + （3 - 1） * 3 + 10 / 2 ， 遇到这个式子我们可能一气呵成就能写出答案是20，因为我们从小学就开始学习数学然后计算，我们太习惯了去做这件事而忘记了去思考为什么要这么做。我们先放慢100倍我们的脑速
四则运算java_四则运算(JAVA)
weixin_42513632的博客
02-18 298
计算过程1.将四则运算串分割出中缀表达式2.将中缀表达式转换为后缀表达式3.对后缀表达式进行求值得出结果import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Objects;import java.util.Stack;public class Eval {pri...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值