Java编写简单计算器

已于 2023-01-10 14:56:23 修改
阅读量9.3k 收藏 197
点赞数 27
文章标签： java 开发语言
于 2022-12-08 10:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cdh4119_/article/details/128231930
版权

本文用Java的swing来实现一个简单计算器，主要内容为图形用户界面GUI的实现以及运算表达式核心算法的设计编写。

程序运行环境为Windows10 ，编译环境为IntelliJ IDEA Community Edition 2022.2.3

一、具体功能：

1、：输入，输出

 输入：允许输入带有括号的完整计算式（例 8*（4-95)+5÷2*e-pi）
 输出：输出Double类型的结果
 输出：整个运算表达式并保存于历史记录中

2、：功能 

 基本的加，减，乘，除，四则运算
 平方运算
 开方运算
 求余运算

最终界面如下图：

 

除了常规的数字按钮和运算符，还有两个常数e，pi（π），清空键AC，括号运算符()，平方(x^x)和开方(sqrt)运算符，输入显示框以及历史记录文本框，文本框的垂直滚动条和水平滚动条。 

二、主要思想：

1：中缀表达式转为后缀表达式

准备：

①后缀表达式队列：postQueue，用于存储逆波兰表达式（其实不用队列排序直接输出也行)
②操作符栈：opStack，对用户输入的操作符进行处理，用于存储运算符

算法思想：

从左向右依次读取算术表达式的元素X，分以下情况进行不同的处理：
（1）如果X是操作数，直接入队
（2）如果X是运算符，再分以下情况：
a）如果栈为空，直接入栈。
b）如果X==”（“，直接入栈。
c）如果X==”）“，则将栈里的元素逐个出栈，并入队到后缀表达式队列中，直到第一个配对的”(”出栈。（注：“(”和“)”都不 入队）
d）如果是其他操作符（+ - * /）,则和栈顶元素进行比较优先级。 如果栈顶元素的优先级大于等于X，则出栈并把栈中弹出的元素入队，直到栈顶元素的优先级小于X或者栈为空。弹出完这些元素后，才将遇到的操作符压入到栈中。
(3)最后将栈中剩余的操作符全部入队。

示意图：

在这里插入图片描述

2、计算后缀表达式

准备：

需要用到一个结果栈Res_Stack ：用于存放计算的中间过程的值和最终结果

 算法思想：

1、从左开始向右遍历后缀表达式的元素。
2、如果取到的元素是操作数，直接入栈Res_Stack，如果是运算符，从栈中弹出2个数进行运算，然后把运算结果入栈
3、当遍历完后缀表达式时，计算结果就保存在栈里了。

示意图：

在这里插入图片描述

三、结果测试

 

分析： 

1、可实现基本四则运算及平方、开方、求余运算。
2、运算表达式可显示于输入界面并保存于历史记录栏
3、输入界面和历史记录栏皆可实现不断字自动换行功能以及滚动条功能
4、不足之处：进行平方和开方运算时其保存在历史记录中的表达式会出现两个等号及两个结果。

四、完整源代码


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


public class Calculator extends JFrame implements ActionListener {
    Calculator() {
        init();
    }

    /**
     * 定义按钮
     */
    private JTextField textField1;
    private JTextArea textField2;
    private JButton buttonzuo;//(
    private JButton buttonyou;//)
    private JButton buttonC;//c
    private JButton buttonCE;//CE
    private JButton buttondele;//<- 删除
    private JButton buttonDiv;//÷
    private JButton button7;//7
    private JButton button8;//8
    private JButton button9;//9
    private JButton buttonAdd;//+
    private JButton button4;//4
    private JButton button5;//5
    private JButton button6;//6
    private JButton buttonSub;//-
    private JButton button1;//1
    private JButton button2;//2
    private JButton button3;//3
    private JButton buttonMul;//x
    private JButton buttonequl;//=
    private JButton button0;//0
    private JButton buttonPoint;//.

    public void init() {
        JFrame frame = new JFrame("The Calculator Of 崔登辉");                  //普通窗口顶层容器   创建标题为“计算器”；
        frame.setLayout(null);                                                   //设置使用特定的布局管理器；
        //单选项按钮
        //按键的排版以及设计需要提前考虑整体的布局合理性，不可出现按键重叠；为了保证美观又需要考虑排版整齐；
        //放置数字0
        button0 = new JButton("0");                                         //注：在给按键命名时要根据按键的大小，否则按键上的标注无法完全显示；
        button0.setBounds(100, 400, 110, 50);
        frame.add(button0);
        //放置数字1
        button1 = new JButton("1");
        button1.setBounds(40, 340, 50, 50);
        frame.add(button1);
        //放置数字2
        button2 = new JButton("2");
        button2.setBounds(100, 340, 50, 50);
        frame.add(button2);
        //放置数字3
        button3 = new JButton("3");
        button3.setBounds(160, 340, 50, 50);
        frame.add(button3);
        //放置数字4
        button4 = new JButton("4");
        button4.setBounds(40, 280, 50, 50);
        frame.add(button4);
        //放置数字5
        button5 = new JButton("5");
        button5.setBounds(100, 280, 50, 50);
        frame.add(button5);
        //放置数字6
        button6 = new JButton("6");
        button6.setBounds(160, 280, 50, 50);
        frame.add(button6);
        //放置数字7
        button7 = new JButton("7");
        button7.setBounds(40, 220, 50, 50);
        frame.add(button7);
        //放置数字8
        button8 = new JButton("8");
        button8.setBounds(100, 220, 50, 50);
        frame.add(button8);
        //放置数字9
        button9 = new JButton("9");
        button9.setBounds(160, 220, 50, 50);
        frame.add(button9);
        //放置 .
        buttonPoint = new JButton(".");                                                   //text：为自动生成的参数的解释词
        buttonPoint.setBounds(40, 400, 50, 50);                            //自动补齐的参数解释词
        frame.add(buttonPoint);
        //放置 +
        buttonAdd = new JButton("+");
        buttonAdd.setBounds(220, 400, 50, 50);
        frame.add(buttonAdd);
        //放置 -
        buttonSub = new JButton("-");
        buttonSub.setBounds(220, 340, 50, 50);
        frame.add(buttonSub);
        //放置 *
        buttonMul = new JButton("*");
        buttonMul.setBounds(220, 280, 50, 50);
        frame.add(buttonMul);
        //放置 /
        buttonDiv = new JButton("/");
        buttonDiv.setBounds(220, 220, 50, 50);
        frame.add(buttonDiv);
        //放置 =
        buttonequl = new JButton("=");
        buttonequl.setBounds(280, 340, 110, 110);
        frame.add(buttonequl);
        //退位键
        buttondele = new JButton("B");
        buttondele.setBounds(280, 220, 110, 110);
        frame.add(buttondele);
        //放置左括号（
        buttonzuo = new JButton("(");
        buttonzuo.setBounds(40, 160, 80, 50);
        frame.add(buttonzuo);
        //放置右括号）
        buttonyou = new JButton(")");
        buttonyou.setBounds(130, 160, 80, 50);
        frame.add(buttonyou);
        //放置C  消除所有输入
        buttonC = new JButton("C");
        buttonC.setBounds(220, 160, 80, 50);
        frame.add(buttonC);
        //放置CE 消除当前输入
        buttonCE = new JButton("CE");
        buttonCE.setBounds(310, 160, 80, 50);
        frame.add(buttonCE);
        //添加表达式文本框 用以输入计算公式
        textField1 = new JTextField();           //文本框
        textField1.setBounds(40, 20, 350, 60);
        frame.add(textField1);
        textField2 = new JTextArea();
        textField2.setBounds(400, 20, 280, 430);
        frame.add(textField2);


        textField1.addActionListener(this);
        buttonzuo.addActionListener(this);
        buttonyou.addActionListener(this);
        buttonC.addActionListener(this);
        buttonCE.addActionListener(this);
        buttondele.addActionListener(this);
        buttonDiv.addActionListener(this);
        button7.addActionListener(this);
        button8.addActionListener(this);
        button9.addActionListener(this);
        buttonAdd.addActionListener(this);
        button4.addActionListener(this);
        button5.addActionListener(this);
        button6.addActionListener(this);
        buttonSub.addActionListener(this);
        button1.addActionListener(this);
        button2.addActionListener(this);
        button3.addActionListener(this);
        buttonMul.addActionListener(this);
        buttonequl.addActionListener(this);
        button0.addActionListener(this);
        buttonPoint.addActionListener(this);

        frame.setBounds(0, 0, 700, 520);       //设置整个图形窗口的大小；（通过窗口名调用）
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)，当点击窗口的关闭按钮时退出程序（没有这一句，程序不会退出）
        frame.setVisible(true);
    }

    String str = null;
    int pointbook = 0;
    int equalbook = 0;
    int zuonum = 0;
    int younum = 0;
    int equnum = 0;


    public void actionPerformed(ActionEvent e) {
        if (equnum == 1) {
            textField1.setText("0");
            equnum = 0;
        }
        //按0
        if (e.getSource().equals(button0)) {
            str = textField1.getText();
            if (str.length() > 16 || str.equals("0") || equalbook == 1) {

            } else {
                textField1.setText(str + "0");
            }
        }
        //按1
        if (e.getSource().equals(button1)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {

            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("1");
            } else {
                textField1.setText(str + "1");
            }
        }
        //当按钮为2时
        if (e.getSource().equals(button2)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("2");
            } else {
                textField1.setText(str + "2");
            }
        }
        //当按钮为3时
        if (e.getSource().equals(button3)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("3");
            } else {
                textField1.setText(str + "3");
            }
        }
        //当按钮为4时
        if (e.getSource().equals(button4)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("4");
            } else {
                textField1.setText(str + "4");
            }
        }
        //当按钮为5时
        if (e.getSource().equals(button5)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("5");
            } else {
                textField1.setText(str + "5");
            }
        }
        //当按钮为6时
        if (e.getSource().equals(button6)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("6");
            } else {
                textField1.setText(str + "6");
            }
        }
        //当按钮为7时
        if (e.getSource().equals(button7)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("7");
            } else {
                textField1.setText(str + "7");
            }
        }
        //当按钮为8时
        if (e.getSource().equals(button8)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("8");
            } else {
                textField1.setText(str + "8");
            }
        }
        //当按钮为9时
        if (e.getSource().equals(button9)) {
            str = textField1.getText();
            if (str.length() > 16 || equalbook == 1) {
            } else if (str.equals("0") || str.equals("")) {
                textField1.setText("9");
            } else {
                textField1.setText(str + "9");
            }
        }
        //当按钮为小数点时
        if (e.getSource().equals(buttonPoint)) {
            str = textField1.getText();
            if (str.length() > 15 || equalbook == 1) {                   //小数点位于操作数的最后一位不执行操作；
            }
            if (pointbook == 0) {                                    //一个操作数仅能有一个小数点，若已经有小数点则不再添加小数点；
                textField1.setText(str + ".");
                pointbook = 1;                                    //小数点判断位置1；
            }
        }
        //每次输入都是一个数字+运算符，一起从数字文本框转而输入到表达式文本框中；
        //当按钮为加号时
        if (e.getSource().equals(buttonAdd)) {
            str = textField1.getText();                              //获取运算符前一个操作数；
            char ch1[] = str.toCharArray();                        //把第一操作数连同+号 进行字符串转字符数组的操作 赋予ch1；
            int length1 = str.length() - 1;                        //length1获取除+号外的第一操作数的位数；
            if ((length1 == -1 || ch1[length1] != ')') && (str.equals("0") || str.equals("") || ch1[length1] == '.' || ch1[length1] == '+' || ch1[length1] == '-' || ch1[length1] == '*' || ch1[length1] == '/' || ch1[length1] == '(' || ch1[length1] == ')')) {
                //当数字为空或为0（操作无意义）；或数字的最后一位是小数点（未输入完毕或输入出错，等待）
            } else {
                textField1.setText(str + "+");   //合并现有表达式和新增表达式
                // 这里解释以下为什么s没有提取到数字框里的符号，因为输入符号时并没有更新数字框，而是直接执行一系列操作，数字框从未出现过运算符；
            }
            pointbook = 0;
        }
        //当按钮为减号时
        if (e.getSource().equals(buttonSub)) {
            str = textField1.getText();
            char ch1[] = str.toCharArray();
            int length1 = str.length() - 1;
            if ((length1 == -1 || ch1[length1] != ')') && (ch1[length1] == '.' || ch1[length1] == '+' || ch1[length1] == '-' || ch1[length1] == '*' || ch1[length1] == '/' || ch1[length1] == '(' || ch1[length1] == ')')) {
            } else {
                textField1.setText(str + "-");
            }
            pointbook = 0;
        }
        //当按钮为乘号时
        if (e.getSource().equals(buttonMul)) {
            str = textField1.getText();
            char ch1[] = str.toCharArray();
            int length1 = str.length() - 1;
            if ((length1 == -1 || ch1[length1] != ')') && (str.equals("0") || str.equals("") || ch1[length1] == '.' || ch1[length1] == '+' || ch1[length1] == '-' || ch1[length1] == '*' || ch1[length1] == '/' || ch1[length1] == '(' || ch1[length1] == ')')) {
            } else {
                textField1.setText(str + "*");
            }
            pointbook = 0;
        }
        //当按钮为除号时
        if (e.getSource().equals(buttonDiv)) {
            str = textField1.getText();
            char ch1[] = str.toCharArray();
            int length1 = str.length() - 1;
            if ((length1 == -1 || ch1[length1] != ')') && (str.equals("0") || str.equals("") || ch1[length1] == '.' || ch1[length1] == '+' || ch1[length1] == '-' || ch1[length1] == '*' || ch1[length1] == '/' || ch1[length1] == '(' || ch1[length1] == ')')) {
            } else {
                textField1.setText(str + "/");
            }
            pointbook = 0;
        }
        //当按钮为左括号时
        if (e.getSource().equals(buttonzuo)) {
            str = textField1.getText();
            char ch[] = str.toCharArray();
            int length = str.length() - 1;
            if (length == -1 || ch[length] == '+' || ch[length] == '-' || ch[length] == '*' || ch[length] == '/') {
                //括号左边是否有数或符号类别的判断；
                textField1.setText(str + '(');     //满足条件则加入左括号；
                zuonum++;                                            //左括号数加一标记；
            }
            if (length == -1 || ch[length] == '+' || ch[length] == '-' || ch[length] == '*' || ch[length] == '/')
                pointbook = 0;
            if (length == 0 || ch[length] == 0) {
                textField1.setText("(");
                zuonum++;
            }
        }
        //当按钮为右括号时；
        if (e.getSource().equals(buttonyou)) {
            str = textField1.getText();
            char ch[] = str.toCharArray();
            int length = str.length() - 1;
            if (Character.isDigit(ch[length]) && zuonum > younum) {      //只有前面是数字的时候且左括号的数量大于右括号的数量的时候才能加右括号；
                younum++;                                                 //右括号数加一标记；
                textField1.setText(str + ')');
            }
            pointbook = 0;
        }
        //当按下C键时；
        if (e.getSource().equals(buttonC)) {
            textField1.setText("0");                  //置当前数字框为0;
            zuonum = 0;                              //当一次计算完成之后，只有按CE按钮才能进行新的计算，因为要清除所有标志位否则会影响下一次操作；
            younum = 0;
            pointbook = 0;
            equalbook = 0;
            textField2.setText(" ");
        }
        //当按钮为CE时,
        if (e.getSource().equals(buttonCE)) {
            textField1.setText("0");                       //清除当前数字框中内容；
            pointbook = 0;                                 //更新小数点状态为0；
        }
        //当按下B时，
        if (e.getSource().equals(buttondele)) {
            str = textField1.getText();
            char []nums=str.toCharArray();
            if (nums[str.length()-1]=='('){
                zuonum--;
            }
            str = str.substring(0, str.length() - 1);
            textField1.setText(str);
        }
        //当按下=时，
        if (e.getSource().equals(buttonequl)) {
            str = textField1.getText();
            if (zuonum != younum) {
                textField1.setText("关系式错误。");
            } else {
                ans(str);
            }
            String s = str + "=" + textField1.getText();
            textField2.setText(s + "\r\n" + textField2.getText());                //将表达式存放在历史记录里。
            equnum = 1;
        }
    }


    /**
     * 提前将 符号的优先级定义好
     */
    private static final Map<Character, Integer> basic = new HashMap<Character, Integer>();

    static {
        basic.put('-', 1);
        basic.put('+', 1);
        basic.put('*', 2);
        basic.put('/', 2);
        basic.put('(', 0);//在运算中  （）的优先级最高，但是此处因程序中需要 故设置为0
    }


    public void ans(String str) {
        String a = toSuffix(str);//传入 一串 算数公式
        textField1.setText(dealEquation(a));

    }

    /**
     * 将  中缀表达式  转化为  后缀表达式
     */
    public String toSuffix(String infix) {
        List<String> queue = new ArrayList<String>();                                    //定义队列  用于存储 数字  以及最后的  后缀表达式
        List<Character> stack = new ArrayList<Character>();                             //定义栈    用于存储  运算符  最后stack中会被 弹空

        char[] charArr = infix.trim().toCharArray();                                    //字符数组  用于拆分数字或符号
        String standard = "*/+-()";                                                        //判定标准 将表达式中会出现的运算符写出来
        char ch = '&';                                                                    //在循环中用来保存 字符数组的当前循环变量的  这里仅仅是初始化一个值  没有意义
        int len = 0;                                                                    //用于记录字符长度 【例如100*2,则记录的len为3 到时候截取字符串的前三位就是数字】
        for (int i = 0; i < charArr.length; i++) {                                        //开始迭代

            ch = charArr[i];                                                            //保存当前迭代变量
            if (Character.isDigit(ch)) {                                                    //如果当前变量为 数字
                len++;
            } else if (Character.isLetter(ch)) {                                            //如果当前变量为  字母
                len++;
            } else if (ch == '.') {                                                        //如果当前变量为  .  会出现在小数里面
                len++;
            } else if (Character.isSpaceChar(ch)) {                                        //如果当前变量为 空格  支持表达式中有空格出现
                if (len > 0) {                                                            //若为空格 代表 一段结束 ，就可以往队列中  存入了  【例如100 * 2  100后面有空格 就可以将空格之前的存入队列了】
                    queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len, i)));    //往 队列存入 截取的 字符串
                    len = 0;                                                            //长度置空
                }
                continue;                                                                //如果空格出现，则一段结束  跳出本次循环
            } else if (standard.indexOf(ch) != -1) {                                        //如果是上面标准中的 任意一个符号
                if (len > 0) {                                                            //长度也有
                    queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len, i)));    //说明符号之前的可以截取下来做数字
                    len = 0;                                                            //长度置空
                }
                if (ch == '(') {                                                            //如果是左括号
                    stack.add(ch);                                                        //将左括号 放入栈中
                    continue;                                                            //跳出本次循环  继续找下一个位置
                }
                if (!stack.isEmpty()) {                                                    //如果栈不为empty
                    int size = stack.size() - 1;                                        //获取栈的大小-1  即代表栈最后一个元素的下标
                    boolean flag = false;                                                //设置标志位
                    while (size >= 0 && ch == ')' && stack.get(size) != '(') {            //若当前ch为右括号，则 栈里元素从栈顶一直弹出，直到弹出到 左括号
                        queue.add(String.valueOf(stack.remove(size)));                    //注意此处条件：ch并未入栈，所以并未插入队列中；同样直到找到左括号的时候，循环结束了，所以左括号也不会放入队列中【也就是：后缀表达式中不会出现括号】
                        size--;                                                            //size-- 保证下标永远在栈最后一个元素【栈中概念：指针永远指在栈顶元素】
                        flag = true;                                                    //设置标志位为true  表明一直在取（）中的元素
                    }
                    while (size >= 0 && !flag && basic.get(stack.get(size)) >= basic.get(ch)) {    //若取得不是（）内的元素，并且当前栈顶元素的优先级>=对比元素 那就出栈插入队列
                        queue.add(String.valueOf(stack.remove(size)));                    //同样  此处也是remove()方法，既能得到要获取的元素，也能将栈中元素移除掉
                        size--;
                    }
                }
                if (ch != ')') {                                                            //若当前元素不是右括号
                    stack.add(ch);                                                        //就要保证这个符号 入栈
                } else {                                                                //否则就要出栈 栈内符号
                    stack.remove(stack.size() - 1);
                }
            }
            if (i == charArr.length - 1) {                                                //如果已经走到了  中缀表达式的最后一位
                if (len > 0) {                                                            //如果len>0  就截取数字
                    queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len + 1, i + 1)));
                }
                int size = stack.size() - 1;                                            //size表示栈内最后一个元素下标
                while (size >= 0) {                                                        //一直将栈内  符号全部出栈 并且加入队列中  【最终的后缀表达式是存放在队列中的，而栈内最后会被弹空】
                    queue.add(String.valueOf(stack.remove(size)));
                    size--;
                }
            }

        }
        return queue.stream().collect(Collectors.joining(","));                            //将队列中元素以,分割 返回字符串
    }


    /**
     * 将 后缀表达式 进行  运算 计算出结果
     *
     * @param equation
     * @return
     */
    public String dealEquation(String equation) {
        String[] arr = equation.split(",");                                    //根据, 拆分字符串
        List<String> list = new ArrayList<String>();                            //用于计算时  存储运算过程的集合【例如list中当前放置  100   20  5  /  则取出20/5 最终将结果4存入list   此时list中结果为  100  4 】


        for (int i = 0; i < arr.length; i++) {                                    //此处就是上面说的运算过程， 因为list.remove的缘故，所以取出最后一个数个最后两个数  都是size-2
            int size = list.size();
            switch (arr[i]) {
                case "+":
                    double a = Double.parseDouble(list.remove(size - 2)) + Double.parseDouble(list.remove(size - 2));
                    list.add(String.valueOf(a));
                    break;
                case "-":
                    double b = Double.parseDouble(list.remove(size - 2)) - Double.parseDouble(list.remove(size - 2));
                    list.add(String.valueOf(b));
                    break;
                case "*":
                    double c = Double.parseDouble(list.remove(size - 2)) * Double.parseDouble(list.remove(size - 2));
                    list.add(String.valueOf(c));
                    break;
                case "/":
                    double d = Double.parseDouble(list.remove(size - 2)) / Double.parseDouble(list.remove(size - 2));
                    list.add(String.valueOf(d));
                    break;
                default:
                    list.add(arr[i]);
                    break;                                    //如果是数字  直接放进list中
            }
        }
        return list.size() == 1 ? list.get(0) : "运算失败";                    //最终list中仅有一个结果，否则就是算错了
    }

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

cdh4119_
关注
  • 27
    点赞
  • 踩
  • 197
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
计算器JAVA
06-26
用JAVA实现的计算器功能，功能包括加、减、乘、除以及开根号，求平方等
java计算器.rar
08-13
java课设 做一个窗体计算器 源码 ①单击计算器上的数字按钮(0、1、2、3、4、5、6、7、8、9)可以设置参与计算的运算数。 ②单击计算器上的运算符按钮(+、一、*、/)可以选择运算符号。 ③单击计算器上的函数按钮可以计算出相应的函数值。 ④单击计算器上的等号(=)按钮显示计算结果。 ⑤在一个文本框中量示当前的计算过程，在一个文本区中显示以往的计算过程。 ⑥单击“保存”按钮可以将文本区中显示的全部计算过程保存到文件:单击“复制”按钮可以将文本区中选中的文本复制到剪贴板;单击 “清除”按钮可以清除文本区中的全部内容。
用java做一个简易的计算器
2301_78863827的博客
03-12 451
System.out.println("1.继续\t2.清空\t");System.out.println("请输入第二个数字");System.out.println("请输入符号");System.out.println("请输入第一个数字");由于初学Java，所以这个计算器只是测试版，功能并不是很多。
计算器java
11-28
通过java实现设计一个计算器的的可视化设计 ，主要有添加事件响应。
java计算器
10-26
使用java代码编写的计算器，适合java初学者学习的小工具。
Java计算器
07-02
Java计算器 课程中做的小软件，就普通计算器的简易功能
Java计算器简易代码
clean43的博客
04-28 4489
【代码】Java计算器简易代码。
Java编写计算器
li1275454303的博客
04-24 6008
主要用JAVA编写一个计算器，能实现加减乘除、开平方、求阶乘等计算功能,计算器有图形化界面，能对异常进行处理，并且检验输入的合法性，对不合法的输入给出具体的提示信息。
使用java语言编写一个简易的计算器（完整代码与详细步骤都有哦！）
热门推荐
AZLAWW的博客
07-10 5万+
【案例介绍】 1.案例描述 本案例要求利用Java Swing 图形组件开发一个可以进行简单的算术运算的图形化计算器。 2.运行结果 运行结果 【案例目标】 学会分析“简易计算器”程序实现的逻辑思路。 能够独立完成“简易计算器”程序的源代码编写、编译及运行。 掌握JavaSwing界面编程的应用。 了解计算器逻辑运算实现。 【案例分析】 要制作一个计算器，首先要知道它由哪些部分组成，如下图所示： 一个简单的图形化界面计算器，需要由界面组件、组件的时间监听器和具体的事件处理逻辑.
计算器Java代码
weixin_48500347的博客
01-13 6102
计算器Java代码 package com.zou.method; import java.util.Scanner; //写一个计算器，实现加减乘除功能，并能够循环接收新的数据，通过用户交互实现。 /* 思路：写四个方法：加减乘除 利用循环+switch进行用户交互 传递需要操作的两个数 输出结果 */ public class Demo06 { public sta
java计算器代码
Tom_boy_的博客
07-05 7911
java计算器代码 ：package a; import java.awt.BorderLayout; import java.awt.Color; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPa.
Java编写简易计算器.doc
05-18
用Java设计了一个简单的计算器，能够实现基本的运算，包括加减乘除等功能，以及清除保存等功能。
java编写简单计算器
11-22
加减乘除开方 三角函数等功能,图形化用户界面，类似windows上的简单计算器
java编写的计算器
01-18
用java编写的最基础的GUI计算器，通俗易懂，小白入门适合看看，大佬勿喷，有错误的地方可以提出来共同进步。
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 737
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 818
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1731
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1000
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 1051
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
使用Java编写简易计算器程序
06-09
好的，下面是一个使用Java编写的简易计算器程序： ```java import java.util.Scanner; public class Calculator { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值