项目一：简单计算器的实现

已于 2023-02-28 10:27:44 修改
阅读量393 收藏 1
点赞数
文章标签： java Powered by 金山文档
于 2023-01-10 13:34:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59554611/article/details/128628467
版权

项目目标和主要内容

  1. 学习图形界面的设计，利用 MFC 应用程序（Java swing 或 QT 框架，或 C#）创建基于对话框的应用程序，添加按钮、编辑框等控件；

  1. 能通过界面按钮控件输入并实现算术表达式，输入的表达式即时在控件中显示，按下“=”按钮能实现运算，并将运算结果输出在控件中显示。能通过界面按钮控件输入并实现算术表达式，输入的表达式即时在控件中显示，按下“=”按钮能实现运算，并将运算结果输出在控件中显示；

  1. 算术表达式求解，是指算术表达式中包括加、减、乘、除、括号等运算符，能求解包含括号的四则混合运算；并且能够检验表达式的合法性。

项目的主要功能

  1. 计算器能够实现混合运算的算术表达式求解；

输入时有足够的容错机制，来尽量避免用户输入不合规的算术表达式。

项目总体框架

系统详细设计

Java Swing搭建的GUI

1）编辑计算器整体界面大小

·界面的大小，初始位置等基础设置

2）添加组件

·以表格的排列形式添加按键，添加输入以及显示用的文本框

3）实现组件功能

·为按钮添加对应的监听事件，使文本框显示对应的输入与输出结果

判断用户输入的字符的类型

1）判断用户输入的是数字、运算符号或“＝”

·根据输入的字符类型，决定应用的算法，并作出一些用户友好的容错设置

·在之前的运行中，数字在以小数点“.”开头时程序会忽略掉小数点只取整数，如用户输入“.5”，程序会将数字修改为“5”，经过修改后通过添加判断条件，当出现类似“.5”的小数点前无数的情况，系统会将该数修改为如“0.5”的数

输出结果

1）根据算法生成结果

·将计算结果返回至输出结果文本框中

关键算法分析

·具体算法

判断输入的字符类型

若输入字符为数字：

①若最新输入数字字符两侧没有运算符，则与先前或之后输入的数字字符共同组成运算用的数字。若与运算符相连，则将运算符之前的所有数字字符组成运算用的数字。

②若与运算符相连，则将运算符之前的所有数字字符组成运算用的数字。

若输入字符为运算符：

①算式的开头与结尾被禁止输入运算符，且禁止多个运算符相连。

②将运算符与其相邻的两个运算用数字共同形成算式。

若输入字符为括号：

①在没有左括号以及括号内无内容时被禁止输入右括号。

②左右括号内的内容将提升算术优先级，如括号中的加减法优先级高于括号外的乘除法。

③在算式结尾缺少所需数量的右括号时，程序会在不修改算式优先级的情况下补充右括号。

若输入字符为等号：

①计算算式的结果。

②将结果返回至输出文本框显示。

若输入字符为退格与清空：

①退格时，清除上一个输入的字符。

②清空时，清空所有输入与输出内容。

源代码

package 计算器;

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 {
    String s = null;
    int PointNumber = 0;  //记录小数点数量
    int EqualNumber = 0; //记录等号数量
    int LNum = 0;       //记录左括号的数量
    int RNum = 0;      //记录右括号的数量

    Button b_0;
    Button b_1;
    Button b_2;
    Button b_3;
    Button b_4;
    Button b_5;
    Button b_6;
    Button b_7;
    Button b_8;
    Button b_9;
    Button b_plus;
    Button b_minus;
    Button b_multiply;
    Button b_divide;
    Button b_decimalpoint;
    Button b_leftbracket;
    Button b_rightbracket;
    Button b_empty;
    Button b_equal;
    Button b_backspace;

    TextField input;
    TextField output;

    JPanel upper;
    JPanel below;

    public Calculator() {
        JFrame frame = new JFrame("计算器");
        frame.setLayout(null);
        frame.setFont(new Font("宋体", Font.BOLD, 25));
        frame.setBounds(200, 200, 550, 625);

        b_0 = new Button("0");
        b_0.addActionListener(this);
        b_1 = new Button("1");
        b_1.addActionListener(this);
        b_2 = new Button("2");
        b_2.addActionListener(this);
        b_3 = new Button("3");
        b_3.addActionListener(this);
        b_4 = new Button("4");
        b_4.addActionListener(this);
        b_5 = new Button("5");
        b_5.addActionListener(this);
        b_6 = new Button("6");
        b_6.addActionListener(this);
        b_7 = new Button("7");
        b_7.addActionListener(this);
        b_8 = new Button("8");
        b_8.addActionListener(this);
        b_9 = new Button("9");
        b_9.addActionListener(this);
        b_plus = new Button("+");
        b_plus.addActionListener(this);
        b_minus = new Button("_");
        b_minus.addActionListener(this);
        b_multiply = new Button("*");
        b_multiply.addActionListener(this);
        b_divide = new Button("/");
        b_divide.addActionListener(this);
        b_decimalpoint = new Button(".");
        b_decimalpoint.addActionListener(this);
        b_leftbracket = new Button("(");
        b_leftbracket.addActionListener(this);
        b_rightbracket = new Button(")");
        b_rightbracket.addActionListener(this);
        b_empty = new Button("empty");
        b_empty.addActionListener(this);
        b_equal = new Button("=");
        b_equal.addActionListener(this);
        b_backspace = new Button("backspace");
        b_backspace.addActionListener(this);


        input = new TextField();
        input.addActionListener(this);
        input.setBounds(20, 140, 170, 40);
        input.setFont(new Font("宋体", Font.BOLD, 30));

        output = new TextField(1000);
        output.addActionListener(this);
        output.setBounds(20, 40, 550 - 50, 80);
        output.setFont(new Font("宋体", Font.BOLD, 35));

        upper = new JPanel(null);
        below = new JPanel(new GridLayout(5, 4));

        upper.setBounds(0, 0, 550, 200);
        upper.setBackground(new Color(250, 250, 250));

        upper.add(input);
        upper.add(output);

        below.setBounds(0, 200, 550, 400);
        below.setBackground(Color.black);

        below.add(b_leftbracket);
        below.add(b_rightbracket);
        below.add(b_empty);
        b_empty.setFont(new Font("宋体", Font.BOLD, 15));
        b_backspace.setFont(new Font("宋体", Font.BOLD, 15));
        below.add(b_backspace);
        below.add(b_7);
        below.add(b_8);
        below.add(b_9);
        below.add(b_divide);
        below.add(b_4);
        below.add(b_5);
        below.add(b_6);
        below.add(b_multiply);
        below.add(b_1);
        below.add(b_2);
        below.add(b_3);
        below.add(b_minus);
        below.add(b_decimalpoint);
        below.add(b_0);
        below.add(b_equal);
        below.add(b_plus);

        frame.setVisible(true);
        frame.add(upper);
        frame.add(below);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource().equals(b_0)) {
            s = input.getText();
            if (s.length() <= 8) {
                if (!s.equals("0") && EqualNumber != 1) {
                    input.setText(s + "0");

                }
            }
        }

        if (e.getSource().equals(b_1)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("1");
                } else {
                    input.setText(s + "1");
                }
            }
        }

        if (e.getSource().equals(b_2)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("2");
                } else {
                    input.setText(s + "2");
                }
            }
        }

        if (e.getSource().equals(b_3)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("3");
                } else {
                    input.setText(s + "3");
                }
            }
        }

        if (e.getSource().equals(b_4)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("4");
                } else {
                    input.setText(s + "4");
                }
            }
        }

        if (e.getSource().equals(b_5)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("5");
                } else {
                    input.setText(s + "5");
                }
            }
        }

        if (e.getSource().equals(b_6)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("6");
                } else {
                    input.setText(s + "6");
                }
            }
        }

        if (e.getSource().equals(b_7)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("7");
                } else {
                    input.setText(s + "7");
                }
            }
        }

        if (e.getSource().equals(b_8)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("8");
                } else {
                    input.setText(s + "8");
                }
            }
        }

        if (e.getSource().equals(b_9)) {
            s = input.getText();
            if (s.length() <= 8 && EqualNumber != 1) {
                if (s.equals("0") || s.equals("")) {
                    input.setText("9");
                } else {
                    input.setText(s + "9");
                }
            }
        }

        if (e.getSource().equals(b_decimalpoint)) {
            s = input.getText();
            if (PointNumber == 0) {
                input.setText(s + ".");
                PointNumber = 1;
            }
        }

        if (e.getSource().equals(b_plus)) {
            s = input.getText();
            char[] ch1 = s.toCharArray();
            int length1 = s.length() - 1;
            String S = output.getText();
            char[] ch2 = S.toCharArray();
            int length2 = S.length() - 1;
            //当数字为空或为0或数字的最后一位是小数点时不作处理
            if ((length2 != -1 && ch2[length2] == ')') || (!s.equals("0") && !s.equals("") && ch1[length1] != '.')) {
                input.setText("");
                output.setText(output.getText() + s + "+");

            }
        }

        if (e.getSource().equals(b_minus)) {
            s = input.getText();
            char[] ch1 = s.toCharArray();
            int length1 = s.length() - 1;
            String S = output.getText();
            char[] ch2 = S.toCharArray();
            int length2 = S.length() - 1;
            if ((length2 != -1 && ch2[length2] == ')') || (!s.equals("0") && !s.equals("") && ch1[length1] != '.')) {
                input.setText("");
                output.setText(output.getText() + s + "-");
            }
        }

        if (e.getSource().equals(b_multiply)) {
            s = input.getText();
            char[] ch1 = s.toCharArray();
            int length1 = s.length() - 1;
            String S = output.getText();
            char[] ch2 = S.toCharArray();
            int length2 = S.length() - 1;
            if ((length2 != -1 && ch2[length2] == ')') || (!s.equals("0") && !s.equals("") && ch1[length1] != '.')) {
                input.setText("");
                output.setText(output.getText() + s + "*");
            }
        }

        if (e.getSource().equals(b_divide)) {
            s = input.getText();
            char[] ch1 = s.toCharArray();
            int length1 = s.length() - 1;
            String S = output.getText();
            char[] ch2 = S.toCharArray();
            int length2 = S.length() - 1;
            if ((length2 != -1 && ch2[length2] == ')') || (!s.equals("0") && !s.equals("") && ch1[length1] != '.')) {
                input.setText("");
                output.setText(output.getText() + s + "÷");
            }
        }

        if (e.getSource().equals(b_leftbracket)) {
            if (!input.getText().equals("0") && !input.getText().contentEquals("")) {
                output.setText(output.getText() + input.getText());
            }
            s = output.getText();
            char[] ch = s.toCharArray();
            int length = s.length() - 1;
            if (length == -1 || ch[length] == '+' || ch[length] == '-' || ch[length] == '*' || ch[length] == '÷' || ch[length] == '(') {
                output.setText(output.getText() + '(');
                LNum++;
            }
        }

        if (e.getSource().equals(b_rightbracket)) {
            if (!input.getText().equals("0")) {
                output.setText(output.getText() + input.getText());
                input.setText("");
            }
            s = output.getText();
            char[] ch = s.toCharArray();
            int length = s.length() - 1;

            if (Character.isDigit(ch[length]) && LNum > RNum) {
                RNum++;
                output.setText(output.getText() + ')');
            }

        }


        if (e.getSource().equals(b_empty)) {
            input.setText("0");
            output.setText("");
            LNum = 0;
            RNum = 0;
            PointNumber = 0;
            EqualNumber = 0;
        }


        if (e.getSource().equals(b_backspace)) {
            int i = input.getText().length();
            int j = output.getText().length();
            output.setText(output.getText().substring(0, j - 1));
            input.setText(input.getText().substring(0, i - 1));
        }


        if (e.getSource().equals(b_equal)) {
            s = input.getText();
            if (!s.equals("0") && !s.equals("")) {
                output.setText(output.getText() + s);

            }

            if (EqualNumber == 0) {
                input.setText("");
                //补全右括号
                for (int i = 0; i < LNum - RNum; i++) {
                    output.setText(output.getText() + ')');
                }


                //算法
                String[] ans = new String[100];
                int Size = 0;
                Stack<Character> Operator = new Stack<>();

                s = output.getText();
                char[] value = s.toCharArray();
                int length = value.length;
                for (int j = 0; j < length; j++) {
                    //当数组元素为数字时
                    if (value[j] >= '0' && value[j] <= '9') {
                        double Number = value[j] - '0';
                        //继续遍历，直到不是数字和小数点
                        //记录小数点是否出现
                        int point = 0;
                        //记录小数点出现后的位数
                        int bit = 1;
                        if (j == length - 1) {
                            ans[Size++] = String.valueOf(Number);
                        }
                        for (j++; j < length; j++) {
                            if ((value[j] < '0' || value[j] > '9') && value[j] != '.') {
                                j--;
                                ans[Size++] = String.valueOf(Number);
                                break;
                            }
                            if (value[j] == '.') {
                                point = 1;
                                continue;
                            }
                            if (value[j] >= '0' && value[j] <= '9') {
                                //当小数点没有出现时和没出现时分开讨论
                                if (point == 0) {
                                    Number = Number * 10 + (value[j] - '0');
                                } else {
                                    Number = Number + Math.pow(10, -bit) * (value[j] - '0');
                                    bit++;
                                }
                            }
                        }
                    } else {
                        //考虑运算符
                        if (value[j] == '(') {
                            Operator.push('(');
                        } else if (value[j] == ')') {
                            while (!Operator.peek().equals('(')) {
                                ans[Size++] = String.valueOf(Operator.peek());
                                Operator.pop();
                            }
                            Operator.pop();
                        } else {
                            if (Operator.empty()) {
                                Operator.push(value[j]);
                            } else {
                                while (true) {
                                    if (Operator.empty()) {
                                        Operator.push(value[j]);
                                        break;
                                    }
                                    char operator1 = Operator.peek();
                                    if ((value[j] == '*' || value[j] == '÷') && (operator1 == '+' || operator1 == '-') || (operator1 == '(' || operator1 == ')')) {
                                        Operator.push(value[j]);
                                        break;
                                    } else {
                                        ans[Size++] = String.valueOf(Operator.peek());
                                        Operator.pop();
                                    }
                                }
                            }
                        }
                    }
                }
                while (!Operator.empty()) {
                    ans[Size++] = String.valueOf(Operator.peek());
                    Operator.pop();
                }
                Stack<Double> Last = new Stack<>();
                for (int i = 0; i < Size; i++) {
                    String s1 = ans[i];
                    char[] element = s1.toCharArray();
                    if (element[0] >= '0' && element[0] <= '9') {
                        Last.push(Double.parseDouble(s1));
                    } else {
                        double num1 = Last.pop();
                        double num2 = Last.pop();
                        double num3 = 0;
                        if (element[0] == '+')
                            num3 = num2 + num1;
                        else if (element[0] == '-')
                            num3 = num2 - num1;
                        else if (element[0] == '*')
                            num3 = num2 * num1;
                        else if (element[0] == '÷')
                            num3 = num2 / num1;
                        Last.push(num3);
                    }
                }
                output.setText(output.getText() + "=" + Last.pop());
                EqualNumber = 1;
            }
        }
    }

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

计算器界面展示：

Van-Hua
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Android的考试系统
06-03
基于Android的考试系统，有用户登录注册功能，用户考试功能。数据库用的是sqlite数据库，在Myeclipse中可以成功运行。系统的功能包括：用户做题，查看错题，查看得分。
android智能手机编程考试答案,Android智能手机编程形考作业
weixin_36064484的博客
05-26 5089
任务1：案例讨论通过修改和优化案例代码的方式修改和优化本单元的“简单计算器”案例。本次活动不限定方向，你可以：阐述设计思路；添加新的计算器功能，如添加正弦函数、余弦函数的计算功能；修改计算器界面，展现运行效果图。活动要求：以主题帖的方式，将代码复制或界面截图发布到讨论区或上传压缩包，以便大家对你的代码进行进一步优化和点评。至少评价两位同学发布的主题帖，且评价要围绕“代码的规范性”、“优化程度”和“...
实验一 简单计算器的实现
qq_48016569的博客
11-25 865
计算器
java编写的一个计算器小程序（图形用户界面组件GUI）
10-19
这只是一个小程序，不过你可以在此基础上扩展功能！
实验一、计算器的程序制作
qq_57592791的博客
11-25 831
实验一，计算器的程序制作
Java实战项目:计算器应用程序 - 实现基本的数学运算功能
10-03
在这篇Java实战博客中，我将向您展示如何使用Java编程语言创建一个简单的计算器应用程序。我们将从创建用户界面开始，然后逐步实现不同的数学运算功能。在整个过程中，我将提供清晰的思路和Java代码示例，以确保您...
简易计算器 （C语言）作业
11-05
要求完成个人项目：简易计算器 分值：10分 功能要求： 1、 功能菜单的显示 2、 可以不断重复选择不同的指令，直到程序退出为止。 3、 实现两个数的加法，减法，乘法，除法四种运算 4、 可以重新输入新的操作数 5、 ...
基于Vue.js 实现的一个简单计算器源码+项目说明.zip
07-27
基于Vue.js 实现的一个简单计算器源码+项目说明.zip 【资源说明】 1、要先 点击答案区域使其获得焦点 才能采用键盘输入。此时右上角会出现 “KEYBOARD ON” 字样。 2、按一下清除键是清除当步，再按一下清除键是清除...
tscalc:使用TypeScript实现的简单计算器包
04-23
我们基于此项目实现了一个简单的Web计算器。 您可以在关注该应用。 安装 使用Node和TypeScript进行构建。 $ git clone https://github.com/cwchentw/tscalc.git $ cd tscalc $ npm install $ npm run build 将dist...
QT小项目实现一个简单的计算器
01-28
QT写一个简单计算器，用了一点简单的布局加上信号与槽机制实现
数据库系统原理实验作业二：可视化程序设计编写计算器程序
m0_49868511的博客
03-21 307
编写计算器程序 一 准备 我的电脑有了vistual studio2010就没有用2019了。 新建一个项目，选Windows窗体应用程序，其他默认，点确定。 找到工具箱会找到一些可视化的工具。 主要使用以下工具 1.textbox：文本框控件 2.button：按钮控件 二 设计 双击或拖动控件，变成下面的样子（每个按钮记着改名字，也可以换换颜色），操作界面就整好了。 三 编写程序 双击每个不同的按钮，可以编写不同功能 using System; using System.Collections
Java课程设计——简易计算器
陌然的博客
01-09 1万+
1.系统简介1.1设计背景随着人们物质生活水平的日益提高，人们对高质量的计算提出了更高的要求。当今世界，是云计算的生活和物联网发展和使用阶段，计算性能的高低和计算的效率直接影响到了人们的生活。对此，使用Java语言开发出一个为人们生活带来便利的计算器，主要完成对数据的高效计算。该系统实现了加、减、乘、除的四则运算。1.2开发工具及环境（1）开发工具及介绍Eclipse是Java集成...
安卓开发编写计算器（工具 android studio）
wujiancai1163的博客
03-16 6668
问题：编写一个计算器。 用网格布局编写界面： activity_main.xml 代码 &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;GridLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.and...
Java课设-百行代码实现简易计算器
热门推荐
qq_57150526的博客
07-04 1万+
Java程序设计 工程实践——简易计算器的设计院、 系 计算机与软件学院 专业 信息安全 姓 名 指导教师2022年 6 月 11 日目录： 一、 设计简介 2 1、 设计背景 2 2、 开发工具及环境 2 （1）开发工具及介绍 2 （2）开发环境 2 二、 相关工作 2 1、设计基础 2 2、功能需求 2 3、系统设计 3 三、 设计原理 3 1、包和类的说明 3 2、简易计算器的源代码清单 3 四、 实现结果 6 1、程序界面 6 2、测试用例 7 3、运行结果 7 五、 设计心得 9一、
界面开发过程中，会使用各种控件
个人博客
06-21 202
  界面开发过程中，会使用各种控件   1. 树形控件（普通树、复选框树）； 2. 菜单控件（纵向菜单、横向菜单）； 3. Tab页控件； 4. 表格控件（基本表格、子母表控件、树形表格、可编辑表格）； 5. 类Portal展现控件（含区域布局控件）； 6. 日历控件（日期选择、时间选择）； 7. 自动完成控件（下拉框自动选择、单选下拉框、多选下拉框）； 8. 工作日历（班表）...
【数据库系统原理实验作业】二：编写计算器程序
Maynine的博客
03-16 594
工程文件下载：https://pan.baidu.com/s/118N1FUDjwqlsbZEwr5lJPQ 提取码：4399 一、下载c# ①登陆网址：https://visualstudio.microsoft.com/zh-hans/ 下载community 2019，登录微软账户即可免费使用vstudio。 ②打开安装程序，选择.NET桌面开发，VS就可以帮下载并配置好C#的运行环境。 二、从创建项目到了解C# ①打开VS，找到windows窗体应用后，点击，然后为你的项目命名。 ②从在设计视
模拟栈
Axiayouqiaomu的博客
01-26 301
模拟栈前言一、模拟栈的实现 前言 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 一、模拟栈的实现 使用数组来模拟栈，下面是代码： #include<bits/stdc++.h> using namespace std;
Java 实验五 图形用户界面设计 制作一个简单的计算器
weixin_51733609的博客
12-14 4162
Java 实验五 图形用户界面设计
【Java GUI】用java实现简单计算器的制作 项目（一）
m0_72091619的博客
05-01 5387
3，设置窗口的各种按钮（需添加数字1~9，小数点，运算符号，括号，等号，清除删除键等等），并往相应按钮中添加相应字符，便于向用户展示相字符的作用（此处不含按钮监听事件），同时也可以优化按钮设置如数字0~9用同一个颜色，运算符用一个颜色，等号用为一颜色用于区分，关于按钮布局可以模仿微软计算器中的布局。3：由于存储字符串时使用的是栈，所以可以同时实现括号匹配问题的判断，某些错误表达式输入的限制如两个运算符不能相邻输入 ：（1+/2）该表达式就是错误的，此时只需要在输入前查看栈顶元素并与输入的元素进行判断即可。
基于qt5实现简易计算器
最新发布
11-03
基于QT5实现简易计算器可以通过以下步骤进行： 1. 首先，在QT Creator中创建一个新的QT Widgets Application项目。 2. 在计算器的界面中，可以使用QT提供的QWidget或QMainWindow作为界面的基类。你可以在界面上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值