基于Java的计算器应用设计

已于 2023-01-08 21:51:40 修改
阅读量207 收藏 1
点赞数 1
文章标签： java
于 2022-10-14 14:51:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73565130/article/details/127320401
版权

一、准备阶段

1、学习frame.panel面板界面的设置

setVisible()可视化

setLayout 排版（Grid 水平 Border 东西南北 Flow 流式）

setSize（） 大小

setBackground（Color）设置背景颜色
setBounds（）设置坐标

pack自适应窗口

2、button按钮的设置

3、监听文本框

textField.addActionListener（）

//需要对象

class MyActionListener1 implements ActionListener
        {


    @Override
    public void  actionPerformed(ActionEvent e) {
        TextField field =(TextField) e.getSource();//获取一些资源，返回一个对象
        System.out.println(field.getText());//获取输入框的文本
        field.setText("");
    }
}

4、运用java编写简单计算器进行双目运算

import java.util.Scanner;



public class Main {

    public static void main(String[] args) {



        Scanner input = new Scanner(System.in);

        int x = input.nextInt();

        int y = input.nextInt();

        char a = input.next().charAt(0);

        switch (a) {

            case '+':

                System.out.println(x + y);

                break;

            case '-':

                System.out.println(x - y);

                break;

            case '*':

                System.out.println(x * y);

                break;

            case '/':

                if (y == 0)

                    System.out.println("Divided by zero!");

                else

                System.out.println(x / y);

                break;

            default:

                System.out.println("Invalid operator!");

        }

    }

}

二、中缀表达式转后缀表达式：

（1）知识储备

1.中缀表达式要转后缀表达式，首先需要两个栈，其中一个应用于存放字符，另一个用于存放数字。

2.读到数字直接存入数字栈中，读到字符时，要与栈内前一元素进行比较，如果当前（要存入的字符）优先级大于前一字符时才存入，否则要将栈内元素弹出，并依次存入数字栈中。

3.遇到 ‘）'时将栈内所有字符依次弹出，并存入数字栈中，直到遇到 ‘（' 为止

4.当所有字符、数字访问完毕时，栈内很可能还会有剩余的字符，这是将他们一次弹出，并存入数字栈中

（2）算法实现
 

private String[] houzhui(String str) {
    String s = "";// 用于承接多位数的字符串
    char[] opStack = new char[100];// 静态栈,对用户输入的操作符进行处理，用于存储运算符
    String[] postQueue = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
    int top = -1, j = 0;// 静态指针top,控制变量j
    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);
                //比如，中缀表达式：234+4*2，我们扫描这个字符串的时候，s的作用相当于用来存储长度为3个字符的操作数：234
            }
            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;
}

三、后缀表达式的计算

（1）知识储备

后缀表达式的计算规则为：当遇到操作数（数字）时就将其入栈，当遇到操作符时就取出栈顶的两个元素，根据当前操作符进行计算，将计算结果再压入栈顶。如果表达式是规整的表达式，在整个表达式扫描完成之后栈顶将只有一个数字，该数据即为计算结果。

（2）算法实现
 

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)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);// 顺序出栈两个数字字符串，并转换为double类型
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("*".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
 
                }
                if ("/".indexOf(str[i]) >= 0) {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "出错";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
            }
        }
        return Result[Top];// 返回最终结果
    }

四、特殊运算的处理

增加了一些特殊的应用环境，使得计算器的功能更加完善，能够进行简单的特殊运算。

1、开方运算

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;
    }

2、平方运算

public String pfys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = Math.pow(a, 2);
        result = String.valueOf(b);
        return result;
    }

3、百分号运算

public String bfhys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = a / 100;
        result = String.valueOf(b);
        return result;
    }

五、源代码

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Objects;

import javax.swing.*;

public class Calculator extends JFrame implements ActionListener {
    private final String[] KEYS = {"√￣", "%", "x²", "AC", "e", "(", ")", "=", "7", "8", "9", "+", "4", "5", "6", "-", "1",
            "2", "3", "*", "π", "0", ".", "/"};
    private JButton keys[] = new JButton[KEYS.length];
    private JTextArea resultText = new JTextArea("0");// 文本域组件TextArea可容纳多行文本；文本框内容初始值设为0.0
    private JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
    private JPanel jp2 = new JPanel();
    private JScrollPane gdt1 = new JScrollPane(resultText);//给输入显示屏文本域新建一个垂直滚动滑条
    private JScrollPane gdt2 = new JScrollPane(History);//给历史记录文本域新建一个垂直滚动滑条
    private JLabel label = new JLabel("历史记录");
    private String b = "";

    // 构造方法
    public Calculator() {
        super("Caculator");
        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());
        JPanel jp1 = new JPanel();
        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);
        gdt2.setViewportView(History);
        gdt2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        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].setBackground(Color.LIGHT_GRAY);
            keys[i].setText(KEYS[i]);
            keys[i].setBounds(x, y, 60, 40);
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                y += 45;
            }
            this.add(keys[i]);
        }
        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();
        if (Objects.equals(label, "="))
        {
            resultText.setText(this.b);
            History.setText(History.getText() + resultText.getText());
            if (label.equals("="))//调用计算方法，得出最终结果
            {
                String[] s = houzhui(this.b);
                String result = Result(s);
                this.b = result + "";
                resultText.setText(this.b);
                History.setText(History.getText()+"=" + resultText.getText()+"\n");
            }
        } else if (Objects.equals(label, "AC"))
        {
            this.b = "";
            resultText.setText("0");//更新文本域的显示，显示初始值;
        } else if (Objects.equals(label, "√￣")) {
            String n = kfys(this.b);
            resultText.setText("√"+this.b);
            this.b = n;
        } else if (Objects.equals(label, "x²")) {
            String m = pfys(this.b);
            resultText.setText(this.b + "^2" + "=" + m);
            this.b = m;
            History.setText(History.getText());
        } else if (Objects.equals(label, "%")) {
            String m = bfhys(this.b);
            this.b = m;
            resultText.setText(this.b);
            History.setText(History.getText());
        } else if (Objects.equals(label, "π") || Objects.equals(label, "e")) {
            if (label.equals("π")) {
                String m = String.valueOf(3.14159265);
                this.b = this.b + m;
                resultText.setText(this.b);
                History.setText(History.getText());
            } else if (label.equals("e")) {
                String m = String.valueOf(2.71828);
                this.b = this.b + m;
                resultText.setText(this.b);
                History.setText(History.getText());
            }
        } else {
            this.b = this.b + label;
            resultText.setText(this.b);
        }
    }

    //将中缀表达式转换为后缀表达式
    private String[] houzhui(String str) {
        String s = "";
        char[] opStack = new char[100];// 存储运算符
        String[] postQueue = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
        int top = -1, j = 0;// 静态指针top,控制变量j
        for (int i = 0; i < str.length(); i++)// 遍历中缀表达式
        {
            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);
        return result;
    }

    //平方运算方法
    public String pfys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = Math.pow(a, 2);
        result = String.valueOf(b);
        return result;
    }

    //百分号运算
    public String bfhys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = a / 100;
        result = String.valueOf(b);
        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)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("*".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);

                }
                if ("/".indexOf(str[i]) >= 0) {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "出错";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);
                    }
                }
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
            }
        }
        return Result[Top];// 返回最终结果
    }

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

ccx1#
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA计算器的图形界面设计_java课程设计报告_简单图形界面计算器的设计.doc
weixin_26741253的博客
03-02 853
PAGEPAGE 2Java 课程设计简单图形界面计算器的设计课程名称 Java程序设计选题名称 简单图形界面计算器的设计专 业班 级姓 名学 号指导教师简单图形界面计算器的设计一、设计任务与目标?本次java程序设计我的设计任务是设计一个图形界面(GUI)的计算器应用程序并且能够完成简单的算术运算。本次任务的基本要求是这个计算器应用程序可以完成十进制的加、减、...
基于java平台简易计算器_基于java的简易计算器的设计
weixin_39988197的博客
02-26 288
基于java的简易计算器的设计 基于java的简易计算器的设计 摘要 自从java语言诞生以来，java语言就以不可抵挡的趋势很快成为国际上广泛流行的面向对象编程语言，它既具有高级语言的特点，又少了C语言中指针特点，因而变得简单了很多。Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，其具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算...
java简单计算器课程设计_简单计算器JAVA课程设计
weixin_34504277的博客
02-17 2338
简单计算器JAVA课程设计一、课程设计目的本课程设计的目标就是要达到理论与实际应用相结合，提高学生组织数据及编写大型程序的能力，并培养基本的、良好的程序设计技能以及合作能力。设计中要求综合运用所学知识，上机解决一些与实际应用结合紧密的、规模较大的问题，通过分析、设计、编码、调试等各环节的训练，使学生深刻理解、牢固掌握数据结构和算法设计技术，掌握分析、解决实际问题的能力。通过这次设计，要求在数据结构...
Java课程设计——计算器
热门推荐
qq_73729080的博客
06-12 1万+
在本教程中，我们将使用Java Swing构建一个科学计算器，Java Swing是一种图形用户界面（GUI）工具包。通过这个项目，我们可以学习如何使用Java Swing创建一个交互式的计算器应用程序，并实现基本的数学运算功能和一些科学计算功能。通过使用Java Swing提供的组件和事件监听器，我们可以创建一个功能强大且用户友好的计算工具。无论是进行基本的数学运算还是执行一些科学计算，这个科学计算器都能够满足我们的需求。
基于Java的计算器
ScriptFlying的博客
04-11 5738
一、课程设计目的和思路: 1、本次课程设计很好的帮助我们复习巩固Java语言的基础知识，进一步加深对Java语言的理解和掌握，通过本次课程设计，能够较全面的掌握面向对象程序设计的有关概念和开发方法，较全面地理解、掌握和综合运用所学的知识，以便提高自身的编程能力，锻炼我们分析解决实际问题的能力。 2、此次Java课程设计是关于图形用户界面的，图形用户界（Graphical User Interfac...
java基础项目 -- 简单计算器的设计与实现
weixin_73861707的博客
04-13 1996
本文将介绍一个简单的计算器应用程序的设计与实现过程，该程序使用了Java语言开发，具有基本的混合四则运算功能，并且支持负数和一些高级运算符的使用。本文介绍了一个基于Java的简单计算器的设计与实现。通过这个项目，我们可以看到如何使用Java Swing库来创建用户界面，并处理用户的输入事件。同时，我们也学习了如何将中缀表达式转换为后缀表达式，并进行计算。
简单计算器的设计java_(基于java的简易计算器的设计.doc
weixin_27605509的博客
02-20 323
(基于java的简易计算器的设计基于java的简易计算器的设计摘要自从java语言诞生以来，java语言就以不可抵挡的趋势很快成为国际上广泛流行的面向对象编程语言，它既具有高级语言的特点，又少了C语言中指针特点，因而变得简单了很多。Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，其具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、...
关于java 计算器设计,Java课程设计报告---设计一个多功能计算器
weixin_27134495的博客
03-09 591
Java课程设计报告---设计一个多功能计算器 存档资料存档资料 成绩成绩 课课 程程 设设 计计 报报 告告 书书 2010-- 2011 年度第 2 学期 所属课程名称所属课程名称 JavaJava 面向对象面向对象程序设计程序设计 题题 目目 设设计计一个多功能计算器一个多功能计算器 分分 院院 电电 信信 分分 院院 专业班级专业班级 0909 信管信管班班 学学 号号 指导教师指导教师 ...
计算机JAVA设计软件,基于Java计算器小软件的设计与实现.doc
weixin_31464715的博客
07-25 364
某某大学毕业论文题 目： 基于Java计算器小软件设计学生姓名： ******学生学号： **********系 别： ****************专 业： ************届 别： 2012指导教师： ******目 录摘 要(1)前言(2...
使用Java编写一个简单的计算器应用程序
luoshenghe的博客
12-08 2584
上述代码中，我们创建了一个JFrame对象作为应用程序的窗口，并设置了标题和大小。然后，我们创建了一个JPanel对象作为GUI界面的容器，并将其布局设置为4行4列的网格布局。通过本文的示例，你学习到了如何使用Java编写一个简单的计算器应用程序，并了解了Java的基础语法和GUI的使用。本文将介绍如何使用Java编写一个简单的计算器应用程序，通过该示例，你将学习到Java基础语法和图形用户界面（GUI）的使用。首先，我们需要创建一个Java项目，并在项目中创建一个GUI界面来容纳计算器的各个组件。
基于java的计算器设计.zip
11-02
在本项目中，我们主要探讨的是如何使用Java编程语言来设计一个计算器应用。这个压缩包文件"基于java的计算器设计.zip"包含了多个计算器程序的源代码，这些代码可以帮助我们理解Java编程的基础，以及如何实现计算器的...
基于JAVA的小型计算器课程设计.pdf
12-01
基于JAVA的小型计算器课程设计 本文档介绍了基于JAVA的小型计算器课程设计的实现方法和过程。该课程设计的目的是设计一个简单的计算器，具有简单的人机交互界面，易于操作，能够进行简单的加、减、乘、除运算。 ...
基于java的简易计算器的设计.pdf
11-29
基于Java的简易计算器的设计 Java是一种广泛使用的编程语言，自从其诞生以来，Java语言就以不可抵挡的趋势很快成为国际上广泛流行的面向对象编程语言。Java语言具有高级语言的特点，同时少了C语言中指针特点，因而...
基于Kotlin和Java的安卓计算器应用设计源码
04-17
本项目是基于Kotlin和Java开发的安卓计算器应用设计源码，共包含26个文件。其中PNG图片文件10个，XML配置文件9个，Kotlin源代码文件3个，Markdown文档2个，项目许可证文件1个，以及Java源代码文件1个。该计算器提供...
基于JAVA语言的计算器设计
12-12
在本文中，我们将深入探讨如何基于Java语言设计一个基本的计算器。这个计算器项目涵盖了GUI（图形用户界面）和CORE计算部分，提供了基本的数学运算，如加法、减法、乘法、除法以及括号的使用。由于设计时考虑的是...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 499
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 748
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 509
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 132
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
JAVA实现的简易计算器课程设计
"基于JAVA的小型计算器课程设计" 这篇报告详细阐述了一个基于Java的小型计算器的课程设计项目。项目的主要目标是让学生掌握Java编程语言，并利用Java构建一个用户友好的、具备基本四则运算功能的计算器软件。 1. *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值