【支持算术表达式求解的计算器】——软件实习项目一

最新推荐文章于 2024-11-08 23:31:31 发布
最新推荐文章于 2024-11-08 23:31:31 发布
阅读量504 收藏 4
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lynnquad/article/details/121539799
版权

一、 项目准备

需求分析：
在这里插入图片描述
编程语言及开发工具：

JAVA，使用IDEA

二、实现过程

1.中缀表达式->后缀表达式

基于堆栈的算法：从左到右扫描每一个字符。

（1）如果扫描到的字符是操作数（如a、b等），就直接输出这些操作数。

（2）如果扫描到的字符是一个操作符，分三种情况：
①如果堆栈是空的，直接将操作符存储到堆栈中（push it）
②如果该操作符的优先级大于堆栈出口的操作符，就直接将操作符存储到堆栈中（push it）
③如果该操作符的优先级低于堆栈出口的操作符，就将堆栈出口的操作符导出（pop it）, 直到该操作符的优先级大于堆栈顶端的操作符。将扫描到的操作符导入到堆栈中（push）。

（3）如果遇到的操作符是左括号"（”，就直接将该操作符输出到堆栈当中。该操作符只有在遇到右括号“)”的时候移除。这是一个特殊符号该特殊处理。

（4）如果扫描到的操作符是右括号“）”，将堆栈中的操作符导出（pop）到output中输出，直到遇见左括号“（”。将堆栈中的左括号移出堆栈（pop ）。继续扫描下一个字符

（5）如果输入的中缀表达式已经扫描完了，但是堆栈中仍然存在操作符的时候，我们应该讲堆栈中的操作符导出并输入到output 当中。

2.后缀表达式的计算。

堆栈法计算后缀表达式的值：
（1）从左到右扫描后缀表达式字符串
（2）初始化一个空栈
（3）如果扫描到数字，那么就直接入栈
（4）如果被扫描的字符是一个二元运算符，那么就连续出栈两次，获得两个字符，元素出栈后，应用运算符进行计算，并将结果压栈
（5）重复3）和4）的操作，直至扫描完字符串
（6）扫描完所有字符串之后，栈中只剩一个元素，该元素就是最终结果，将其出栈并返回。

3.GUI界面的设计
1.JAVA swing 各组件的混合运用；
2.按钮的监听；
3.界面的设计；

关于界面设计的学习详见以下博客 ，带着耐心从中慢慢学习使我受益良多。
https://blog.csdn.net/xietansheng/article/details/72814492

三、完整代码

具体细节和难点详见代码注释。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javax.swing.*;

//主类，继承JFrame框架，实现事件监听器接口
public class Main extends JFrame implements ActionListener {
    String []KEYS = { "7", "8", "9", "C", "4", "5", "6", "back", "1", "2", "3", "+", "0", ".", "pi", "-", "sqrt",
            "%", "/", "*", "AC", "(", ")", "=" };
    JButton []keys = new JButton[KEYS.length];
    JTextArea resultText = new JTextArea("0.0");// 文本域组件TextArea可容纳多行文本；文本框内容初始值设为0.0
    JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
    JPanel jp1=new JPanel();
    JPanel jp2=new JPanel();
    JScrollPane gdt1=new JScrollPane(resultText);//给输入显示屏文本域新建一个垂直滚动滑条
    JScrollPane gdt2=new JScrollPane(History);//给历史记录文本域新建一个垂直滚动滑条
    JLabel label = new JLabel("历史记录");
    String b="";
    static int index;
    static int left,right;//左右括号标记
    static int count;//成功运算标记
    Font font = new Font("TIMES NEW ROMAN", Font.PLAIN, 14);//设置字体
    // 构造方法
    public Main() {
        super("实用计算器");
        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());
        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);
        jp1.add(gdt1);//将滚动条添加入面板窗口中
        jp2.add(gdt2);
        this.add(jp1);//将面板添加到总窗体中
        this.add(jp2);//将面板添加到总窗体中
        this.setLayout(null);
        this.add(label);// 新建“历史记录”标签

        // 放置按钮
        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, 62, 40);
            keys[i].setBackground(new Color(144, 201, 108));//设置按钮颜色
            keys[i].setFont(font);//设置按钮字体
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                y += 45;
            }
            this.add(keys[i]);
        }
        keys[16].setBackground(Color.ORANGE);
        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) {
        String label=e.getActionCommand();//获得事件源的标签
        left=0;
        right=0;
        index=resultText.getText().length()-1;
        if(!resultText.getText().equals("")){
            //计算括号的数量
            for(int i=resultText.getText().length()-1;i>=0;i--){
                switch (resultText.getText().charAt(i)) {
                    case '(' -> left++;
                    case ')' -> right++;
                }
            }
            //找到最后一个数字的下标
            if(!"+-*/()".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                for(;index>0;index--){
                    if("+-*/(".contains(resultText.getText().charAt(index)+"")){
                        break;
                    }
                }
            }
        }

        if("0123456789".contains(label)){//输入数字时：
            if(count==1){//文本框内为上一个有效算式的答案，则替换为后输入的数字
                b=label;
                resultText.setText(b);
                count=0;
            }
            else if(("0".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")&&
                    resultText.getText().length()<=1)){//无法输入0开头的整数
                b=label;
                resultText.setText(b);
            }
            else if(("0".contains(resultText.getText().charAt(resultText.getText().length()-1)+""))&&
                    ("+-*/%".contains(resultText.getText().charAt(resultText.getText().length()-2)+""))){
                StringBuilder BK = new StringBuilder(this.b);//无法输入0开头的整数
                resultText.setText(BK.substring(0, this.b.length() - 1)+label);
                b=resultText.getText();
            }
            else{
                this.b = this.b + label;
                resultText.setText(b);
            }
        }

        //输入左括号时
        else if(label.equals("(")){
            if(b.equals("")){
                resultText.setText("(");
                b=resultText.getText();
            }
            //前面是数字和右括号时补乘，是小数点时无法输入
            else if("0123456789)".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"*(";
                resultText.setText(resultText.getText()+"*(");
            }
            else if(".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }
            else{
                b=b+"(";
                resultText.setText(resultText.getText()+"(");
            }
        }

        else if (label==")"){//输入右括号时
            if (b.equals("")){//表达式为空时不做响应
            }
            else if("+-*/(".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")
            ||left==right){//运算符、左括号后不能跟右括号，左右括号数量匹配时不能输入右括号
            }
            //前面是右括号时补乘
        else if(b.length()>0&&(")".contains(resultText.getText().charAt(resultText.getText().length()-1)+""))){
            b=b+"*"+label;
            resultText.setText(b);
        }
            else {
                resultText.setText(resultText.getText()+")");
                b=resultText.getText();
            }
        }

        else if(label=="."){//输入小数点时
            if(count==1){//文本框内为上一个有效算式的答案，则替换
                b="0"+label;
                resultText.setText(b);
                count=0;
            }
            if((b.equals(""))
                    ||"(+-*/".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"0.";
                resultText.setText(b);
            }
            else if(")".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"*0.";//前面是右括号时补乘
                resultText.setText(b);
            }
            else if (".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }//前面是小数点时不作响应

            else if(!b.substring(index+1).contains(".")){//前面是不带小数点的数字时正常输入
                b=b+".";
                resultText.setText(b);
            }
            else{//前面是带小数点的数字时不响应
            }
        }

        else if(label.equals("=")){//输入等于号时,调用计算方法，得出最终结果
            //resultText.setText(this.b);
            History.setText(History.getText()+resultText.getText());
            if (".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                StringBuilder BK = new StringBuilder(this.b);
                resultText.setText(BK.substring(0, this.b.length() - 1));
                this.b=resultText.getText();
            }
                try {
                    String s[] = Calculate(this.b);
                    String result = Result(s);
                    this.b = result + "";
                    double Test1;
                    Test1=Double.parseDouble(this.b);//将答案字符串转换成双精度型数据检测是否有错误
                    //更新文本框，当前结果在字符串b中，并未删除，下一次输入接着此结果以实现连续运算
                    resultText.setText(this.b);
                    History.setText(History.getText() + "=" + resultText.getText() + "\n");
                    count=1;
                }catch (Exception e1){//抓取错误，不参与运算并提示输入错误，并将文本区域初始化
                    JOptionPane.showMessageDialog(null,"表达式错误");
                    History.setText(History.getText() +"：表达式不完整或将0设置为了除数" + "\n");
                    this.b="";
                    resultText.setText("0");
                }

        }

        else if(label=="C"){ //清空按钮，消除显示屏文本框前面所有的输入和结果
            this.b="";
            resultText.setText("0");//更新文本域的显示，显示初始值;
        }

        else if(label=="sqrt") {//开方功能并不完善，目前只能用于单目运算
            String n=kFys(this.b);
            resultText.setText("sqrt"+"("+this.b+")"+"="+n);//使运算表达式显示在输入界面
            History.setText(History.getText()+resultText.getText()+"\n");//获取输入界面的运算表达式并使其显示在历史记录文本框
            this.b=n;
        }

        else if(label=="AC") {
            this.b="";
            resultText.setText("0");
            History.setText(" ");
        }

        else if(label=="pi") {
            String m=String.valueOf(3.14159265);
            this.b=this.b+m;
            resultText.setText(this.b);
        }

        else if(label=="back"&&this.b.length()>1) {//退格
            StringBuilder BK = new StringBuilder(this.b);
            resultText.setText(BK.substring(0, this.b.length() - 1));
            this.b=resultText.getText();
        }

        else if((label=="back")&&(this.b.length()<=1)){//防止文本框为空时打印退格键
            this.b="";
            resultText.setText("0");
        }

        else if (label=="-"){//运算符后不能输入减号
            if("+-*/.".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }
            else{
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }

        else if(label=="+"||label=="*"||label=="/"||label=="%"||label=="sqrt") {//输入运算符时
            if("+-*/(%.".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }//运算符后不能输入运算符
            else if(b.length()==0) {//当文本框为空时无法输入减号以外的运算符
            }
            else{
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }

        else {
            b = b + label;
            resultText.setText(this.b);
        }
    }

    //将中缀表达式转换为后缀表达式
    public   String[] Calculate(String str) {
        char opStack[] = new char[100];// 静态栈,对用户输入的操作符进行处理，用于存储运算符
        String postQueue[] = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
        int top = -1, j = 0; // 静态指针top,控制变量j

        if(str.charAt(0)=='-'){//如果表达式以负号开头,在最前面补一个0,方便计算
            str="0"+str;
        }
        StringBuilder addZero= new StringBuilder(str);//将表达式中的所有"(-"变为"(0-"以方便计算
        if(str.contains("(-")){
            do{
                addZero.insert(addZero.indexOf("(-")+1,'0');
                str=addZero.toString();
            }while (str.contains("(-"));
        }
        // 用于承接多位数的字符串
        String s = "";
        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);
                }
                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 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)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                BigDecimal x, y, n;
                x = BigDecimal.valueOf(Double.parseDouble(new BigDecimal(Result[Top]).toString()));// 顺序出栈两个数字字符串，并转换为double类型
                Top--;
                y = BigDecimal.valueOf(Double.parseDouble(new BigDecimal(Result[Top]).toString()));
                Top--;
                if ("-".indexOf(str[i]) >= 0) {
                    n = y.subtract(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y.add(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("*".indexOf(str[i]) >= 0) {
                    n = y.multiply(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈

                }
                if ("/".indexOf(str[i]) >= 0){
                        n = y.divide(x,5,RoundingMode.HALF_UP);
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("%".indexOf(str[i]) >= 0) {
                   double num1= Double.parseDouble(String.valueOf(y));
                   double num2= Double.parseDouble(String.valueOf(x));
                        n = BigDecimal.valueOf(num1%num2);
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
            }
        }
        return Result[Top];// 返回最终结果
    }

    // 主函数
    public static void main(String[] args) {
        Main test = new Main();
    }
}

四、遇到的问题及其解决过程

1.非法表达式的识别
请添加图片描述

当输入如图非法表达式时，会因为括号数未匹配而无法返回正确值。
解决方法：
在“＝”的执行语句后使用以下代码抓取错误并提示

catch (Exception e1){//抓取错误，不参与运算并提示输入错误
                    JOptionPane.showMessageDialog(null,"表达式错误");
                    History.setText(History.getText() +"：此表达式错误" + "\n");

添加后结果如下：
在这里插入图片描述
2.负数的运算问题
程序会因为无法运算负数而直接报错

解决方法：
加入以下“补零”代码

if(str.charAt(0)=='-'){//如果表达式以负号开头,在最前面补一个0,方便计算
          str="0"+str;
      }
      StringBuilder addZero= new StringBuilder(str);//将表达式中的所有"(-"变为"(0-"以方便计算
      if(str.contains("(-")){
          do{
              addZero.insert(addZero.indexOf("(-")+1,'0');
              str=addZero.toString();
          }while (str.contains("(-"));
      }

在这里插入图片描述

五、程序功能演示

在这里插入图片描述
程序界面分为左边的操作显示区和右侧的历史记录区。
能提示被除数不允许为0等表达式异常产生的错误。
在这里插入图片描述
有退格、清空历史记录等便利功能
其中开方功能并不完善，目前只能进行单目运算。
在这里插入图片描述

12.20日补充
在经过修改后，计算器有了更智能的输入功能，例如所输入的右括号数量只能小于等于左括号数量，小数点前无数字时自动补零，无法连续输入运算符等等，期间也遇到bug越写越多的情况，但耐心写下来收获甚至不小于刚写完框架，之前没注意到的各种细节被慢慢完善很有成就感。

Lynnquad
关注
计算机软件技术实习 项目一 支持算术表达式求解的计算器（实验准备）
Jcm_666的博客
10-11 324
记录简易计算器设计时的一些关键算法思想：堆栈法、双栈算符优先级法、二叉树求解法
【使用java swing制作简易贪吃蛇游戏】软件实习项目二
Lynnquad的博客
12-26 2256
一、项目准备 需求分析： 实现贪吃蛇游戏基本功能，屏幕上随机出现一个“食物”，称为豆子，上下左右控制“蛇”的移动，吃到“豆子”以后“蛇”的身体加长一点,得分增加，“蛇”碰到边界或，蛇头与蛇身相撞，蛇死亡，游戏结束。为游戏设计初始欢迎界面，游戏界面，游戏结束界面。 编程语言及开发工具： java 基于IDEA 二、实现过程 在屏幕区域内绘制出一条小蛇，并且在与蛇不重合的屏幕区域内随机出现一个食物，游戏者通过键盘操纵游戏小蛇上下左右移动来吃到食物，当食物成功被小蛇吃到后，会在另外的区域重新刷新出食物，而小蛇由于
实验一、支持算术表达式求解的计算器
chi_choo的博客
11-25 333
要求： （1）能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录； （2）能够检验算术表达式的合法性； （3）能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； （4）要求交互界面友好，程序健壮。 ...
数据结构课程设计——算术表达式计算器
weixin_63586982的博客
05-26 2723
目录 一、问题描述 基本要求 二、问题分析 实现思路 三、逻辑设计 1.界面设计 2.程序设计 四、物理设计 1.calculator方法 2.actionPerformed方法 3.infixToSuffix方法 4.result方法 一、问题描述 设计一个简单的算术表达式计算器 基本要求 实现四则运算表达式的求值（包含括号，可多层嵌套） 二、问题分析 目前的计算器大多使用后缀表达式来进行计算，因此基本思想是将用户输入的中缀表达式转为后缀表达式，即逆波兰式，进而..
实现支持算术表达式求解的计算器——计算机软件技术实习（项目一）
m0_51762479的博客
11-17 286
使用Java swing实现支持算术表达式求解的计算器
制作简易计算器——计算机软件技术实习
Real_orchid的博客
09-07 243
qt 计算器
软件实习项目1——计算器的设计与实现（实验准备）
Mirrracle的博客
11-30 889
软件实习项目1——计算器的设计与实现（实验准备）项目要求项目思路理论准备中缀表达式后缀表达式 项目要求 1、能通过设计的按钮控件输入并实现简单算术运算，要求表达式在编辑框中显示，能将运算结果，输出在编辑框内显示； 2、能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符；并且能够识别括号，优先级正确。 3、并保存历史的表达式运算记录。 技术准备：图形界面的开发； 难点：中缀表达式->后缀表达式，后缀表达式的计算。 项目思路 1、实现中缀表达式到后缀表达式的转换。 2、按照后缀表达式的运
计算机软件实习预习 项目一 简单计算器
qq_62459166的博客
12-03 323
计算机软件实习预习 项目一 简单计算器
计算机软件技术实习项目一（一） 简易计算器项目准备
qq_45155131的博客
12-27 971
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 ...
算术表达式的求解-数据结构课程设计报告.pdf
10-01
算术表达式的求解 - 数据结构课程设计报告 本报告详细介绍了算术表达式的求解的设计和实现，使用栈结构来实现算术表达式的求解过程。报告分为三个部分：需求分析、设计构想和详细设计。 需求分析部分： * 需要...
《算术表达式的求解》C语言 代码
03-05
给定一个算术表达式，通过程序求出最后的结果。 1、从键盘输入要求解的算术表达式； 2、采用栈结构进行算术表达式的求解过程（不用栈结构验收不合格）； 3、能够判断算术表达式正确与否； 4、对于错误表达式给出提示...
计算机软件技术实习 项目一 支持算术表达式求解的计算器（预习）
guiguiwulu的博客
10-13 177
记录学习自用
spring循环依赖解决方式
qq_36400213的博客
11-04 889
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
LJH_laura_li的博客
11-08 158
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 38
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
最新发布
shangan_3的博客
11-08 98
【代码】JAVA学习接口案例实例。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 417
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 364
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
使用JavaScript实现算术表达式计算器
1. **存储当前输入**：我们需要一个变量来保存用户在输入框中输入的算术表达式。这可以通过获取input元素的值并更新该变量来实现。例如，我们可以创建一个全局变量`var inputExpression = "";`，并在`test`函数中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值