03-告别语法混乱！Java基础语法：理清变量、数据类型与运算符🔥 前言 "木圭，为什么我定义的变量总是报红？"" 自

🔥 前言
"木圭，为什么我定义的变量总是报红？"" 自增运算符放在前面和后面到底有啥区别？""类型转换为啥总丢精度？"
初学 Java 语法时，我踩过无数坑：变量作用域搞混、运算符优先级记错、隐式转换没注意导致程序报错... 这些看似基础的问题，却让新手频频卡壳。
今天这篇，我把 Java 基础语法的核心知识点（变量、数据类型、运算符等）重新梳理了一遍，专门标注了新手最容易踩坑的细节，都是我亲测过的血泪教训。
📌 本文你将获得：

注释、关键字、字面量的核心用法与示例
变量定义的 6 大注意事项（避坑指南）
数据类型的取值范围与转换规则
各类运算符的使用场景与优先级
Scanner 键盘输入的完整步骤与注意事项

👋 关于作者 我是木圭，正在学习 AI 智能应用开发集训，这是我从 0 开始系统学习 Java 的第 3 篇笔记。我会持续记录从 0 基础到能独立开发 AI 应用的完整过程，包括学习笔记、项目实战、避坑指南。 关注我，一起见证从小白到开发者的成长之路！

📅 学习进度：第 2 天 | JavaSE 阶段（共 17 篇，已完结 3 篇）

1- 注释

注释：是对代码的解释说明，提高代码的可读性
注释分为三种：

单行注释
单行注释：添加两个斜杠，只对当前行有效
IDEA快捷键：Ctrl+/
多行注释
多行注释：添加一对斜杠和星号，对多行有效
IDEA快捷键：Ctrl+Shift+/
文档注释
文档注释：对整个类、方法或字段进行说明
示例代码如下：

public class Demo1 {  
     /**  
      *  文档注释  
      *  @param args 命令行参数  
      *  主方法，程序的入口点，程序从这里开始执行  
      */  
    public static void main(String[] args) {  
        // 单行注释：添加两个斜杠，只对当前行有效  
        // IDEA快捷键：Ctrl+/  
  
        /*         
         * 多行注释：添加一对斜杠和星号，对多行有效  
         * IDEA快捷键：Ctrl+Shift+/  
         * 可以注释多行代码  
         */  
        /*            
        	System.out.println("多行注释");  
            System.out.println("多行注释");  
        */        
        System.out.println("HelloWorld");  
    }  
}

注意：被注释的内容, 不会参与程序的编译和运行

2- 关键字和字面量

2.1 关键字

Java 关键字：即被Java赋予了特殊含义的英文单词。
Java 中常见关键字有：

2.2 字面量

字面量：直接在代码中写出的值，比如 100、3.14、"Hello World" 等。

字面量代码示例如下：

public class Demo3 {  
    public static void main(String[] args) {  
        System.out.println("姓名：马超，高机动、高爆发、依赖移速与存枪机制的战士 / 刺客");  
        System.out.println("被动技能：魔影突袭（核心）");  
        System.out.println("技能1：萧索之刃（远程消耗 / 存枪）");  
        System.out.println("技能2：日落孤枪（范围减速 / 近身存枪）");  
        System.out.print("技能图标：");  
        System.out.println('Q');  
        System.out.print("生命值：");  
        System.out.println(100);  
        System.out.print("技能冷却时间：");  
        System.out.println(10.5);  
        System.out.print("是否可以上分：");  
        System.out.println(true);  
        System.out.print("皮肤数量：");  
        System.out.println(6);  
    }  
}

运行结果：

3- 变量

3.1 变量的介绍与定义

变量：存储数据的容器，用来存储数据
变量声明格式：数据类型变量名 = 值;
变量的定义与使用示例代码：

public void test1(){  
    // 变量：存储数据的容器，用来存储数据  
    // 变量声明格式：数据类型 变量名 = 值;  
    System.out.println("变量的声明格式：数据类型 变量名 = 值;");  
    int a = 10;  
    // 变量的使用  
    System.out.println(a);// 10  
    //变量是可以变化的，可以再赋值  
	//变量的赋值：变量名 = 值;  
	a=20;  
	System.out.println(a);//20
}

3.2 变量的注意事项

变量要先声明才能使用

public void test2(){  
    System.out.println("1. 变量要先声明才能使用");  
    int b=20;  
    System.out.println(b);  // 20
    //System.out.println(c);//报错，c未声明  
}

2. 变量是什么类型，就必须装什么类型的数据

public void test3(){  
    System.out.println("2. 变量是什么类型，就必须装什么类型的数据");  
    int c = 10;  
    //int c=20.0 ;//错误，int只能装int，20.0为浮点型
}

3. 变量只在自己所归属的 { } 范围内有效

public void test4(){  
    System.out.println("3. 变量只在自己所归属的 { } 范围内有效");  
    String name = "张三";  
    System.out.println(name);  
    {  
        int age=18;  
        System.out.println(age);//18  
    }  
    System.out.println(name);//张三  
    //System.out.println(age);// 报错，age没在同一个范围内，不能使用  
}

4. 同一个范围内，变量的名称不能一样

public void test5(){  
    System.out.println("4. 同一个范围内，变量的名称不能一样");  
    int age=20;  
    {  
        int num=10;//正确定义变量，属于不同范围，可以定义  
    }  
    {        int num=20;//正确定义变量，属于不同范围，可以定义  
    }  
    //int age=30;//错误，因为age已经定义过了，不能重复定义  
}

5. 变量定义的时候可以不赋初始值，但在使用时，变量里必须有值

public void test6(){  
    System.out.println("5. 变量定义的时候可以不赋初始值，但在使用时，变量里必须有值");  
    int i;  
    i=10;  
    System.out.println(i);  
    int j;  
    //System.out.println(j);//错误，j未赋值，不能使用  
}

6. 一条语句可以定义多个同类型变量，中间使用逗号分隔

public void test7(){  
    System.out.println("6. 一条语句可以定义多个同类型变量，中间使用逗号分隔");  
    //注意事项：必须保持变量类型一致  
    int a=10,b=20,c=30;  
    System.out.println(a);//10  
    System.out.println(b);//20  
    System.out.println(c);//30  
}

4- 标识符

标识符：就是给类，方法，变量等起名字的符号（自己起的名字）

4.1 标识符命名规则

只能由字母、数字、下划线和美元符号$组成
不能以数字开头
不能用 Java 关键字
区分大小写
标识符示例代码如下：

public class IdentifierDemo {  
    public static void main(String[] args) {  
        int a = 10;  
        System.out.println(a);  
        int $b = 20;  
        System.out.println($b);  
        // int 1a = 30; //错误，不能以数字开头  
        // int class = 40; //错误，不能是关键字class  
        int Class = 40; //正确，区分大小写  
        System.out.println(Class);  
        int _class = 50;  
        System.out.println(_class);//正确，下划线可以出现在标识符中  
        int class$ = 60;  
        System.out.println(class$);//正确，美元符号可以出现在标识符中  
        // int class- = 70; //错误，不能包含特殊符号-  
    }  
}

4.2 标识符命名规范

标识符命名规范：驼峰命名法

小驼峰式命名法（lowerCamelCase）：第一个单词首字母小写，后面每个单词的首字母大写。适用于变量、方法名等。例如：userName、userInfo等。

String userName = "张三";  
System.out.println(userName);

2. 大驼峰式命名法（UpperCamelCase）：所有单词的首字母都大写。适用于类名、接口名等。例如：UserInfo、UserService等。

补充：常量命名规范：常量名全部大写，单词之间用下划线分隔。例如：MAX_VALUE、PI等。

final int MAX_VALUE = 100;  
System.out.println(MAX_VALUE);  
final double PI = 3.14;  
System.out.println(PI);

5- 数据类型

数据类型：数据类型指的是一组值的集合，比如整型、浮点型、字符型等。
数据类型分为两大类：

基本数据类型
引用数据类型
本文先重点聊基本数据类型

5.1 基本数据类型

基本数据类型使用思路：

整数类型变量：首选 int，如果发现 int 装不下数据了，将类型换成 long，但是定义 long 类型变量，需要加入 L 标识
小数类型变量：首选 double，如果非要使用 float 类型，需要在数值后面加入 F 标识

基本数据类型的取值范围边界值，示例代码如下：

// byte 字符范围 -128~127byte byteMax = 127;  
byte byteMin = -128;  
//byte byteOverflow = 128; //错误，超出范围  
// short 字符范围 -32768~32767short shortMax = 32767;  
short shortMin = -32768;  
// short shortOverflow = 32768; //错误，超出范围  
  
// int 字符范围 -2147483648~2147483647int intMax = 2147483647;  
int intMin = -2147483648;  
// int intOverflow = 2147483648; //错误，超出范围  
  
// long 字符范围 -9223372036854775808~9223372036854775807long longMax = 9223372036854775807L;  
long longMin = -9223372036854775808L;  
// long longOverflow = 9223372036854775808L; //错误，超出范围  
  
// float 字符范围 ±3.4028235E38float floatMax = 3.4028235E38F;  
float floatMin = -3.4028235E38F;  
// float floatOverflow = 3.4028235E39F; //错误，超出范围  
  
// double 字符范围 ±1.7976931348623157E308double doubleMax = 1.7976931348623157E308;  
double doubleMin = -1.7976931348623157E308;  
// double doubleOverflow = 1.8E309; //错误，超出范围  
  
// char 字符范围 \u0000~\uffff (0~65535)char charValue = 'a';  
char charMin = '\u0000';  
char charMax = '\uffff';  
  
// boolean 字符范围 true/falseboolean boolTrue = true;  
boolean boolFalse = false;

5.2 基本数据类型细节补充

所有整数默认是 int 类型

System.out.println(10);
//整数10是一个字面量, 但也是Java中的一份数据, 是数据就会有类型, 整数默认是int

2. 所有小数默认是 double 类型

System.out.println(12.3);
整数12.3是一个字面量, 但也是Java中的一份数据, 是数据就会有类型, 小数默认是 double

3. 字符类型的取值范围是 0~65535
原因 : 每一个字符底层都有一份数值的表示形式。

举例：
'a' ---> 二进制表示为 0110 0001（高四位+低四位） --> 转换为十进制为 97
'a' 的数值表示为 97
因此定义字符类型的变量可以是: char c = 97;

5.3 面试题

问：基本数据类型有哪些？
答：
基本数据类型有4类，分别是整型、浮点型、字符型、布尔型；
其中整型有byte、short、int、long；分别占用1、2、4、8个字节；
浮点型有float、double；分别占用4、8个字节；
字符型有char；占用2个字节；
布尔型有boolean。占用1个字节；

6- 运算符

6.1 算术运算符

算术运算符：用来进行数学运算的符号，如加号（+）、减号（-）、乘号（*），除号（/）、求余（%）。

注意事项：

/与%的区别：
- /：整数除法，只保留结果的整数部分。
- %：取余数，返回两数相除的余数。
整数操作只能得到整数，如果要得到小数，则需要有一个操作数为浮点类型。

6.1.1 算术运算符示例代码

// 算数运算符：  
int a = 100;  
int b = 21;  
System.out.println("算数运算符：");  
// 加： +System.out.println("加： +");  
System.out.print("a+b=");  
System.out.println(a + b);// 101  
// 减： -System.out.println("减： -");  
System.out.print("a-b=");  
System.out.println(a - b);// 79  
// 乘： *System.out.println("乘： *");  
System.out.println(a * b);// 2100  
// 除： /：整数除法  
System.out.println("除： /");  
System.out.println(a / b);// 4  
// 取余： %：取余数  
System.out.println("取余： %");  
System.out.println(a % b);// 16

6.1.2 案例：数值拆分

public class OperatorDemo2 {  
    public static void main(String[] args) {  
        // 数值拆分：456  
        int num = 456;  
        int a = num % 10;  
        int b = num / 10 % 10;  
        int c = num / 100;  
        System.out.println("个位：" + a);// 6  
        System.out.println("十位：" + b);// 5  
        System.out.println("百位：" + c);// 4  
    }  
}

6.2 字符串拼接

字符串拼接：当 + 操作中，遇到了字符串，这时 + 就是字符串连接符，而不是算术运算。
Java 里的 + 有两个核心作用：

纯数字之间：做加法运算
只要出现字符串：做字符串拼接，并且遵循从左到右的顺序执行

System.out.println("字符串拼接：");  
//字符串+字符串，会进行字符串拼接  
System.out.println("hello" + "world");// helloworld  
//字符串+数字：全程都是字符串拼接  
System.out.println("hello" + 1);// hello1  
//数字+字符串：会先进行数字运算，再进行字符串拼接  
System.out.println(1+2+"hello");// 3hello

6.3 自增自减运算符

自增自减运算符
++：自增运算符
--：自减运算符

6.3.1 自增自减运算符的使用

单独使用: 符号在前在后没有区别的

int a = 10;  
a++;  
System.out.println("a++ 后：" + a);  // 11  
a--;  
System.out.println("a-- 后：" + a);  // 10  
  
int x = 10;  
++x;  
System.out.println("++x 后：" + x);  // 11  
--x;  
System.out.println("--x 后：" + x);  // 10

2. 放在表达式中：++a: 先运算再赋值

int b=++a;  
System.out.println(a);// 11  
System.out.println(b); // 输出11

3. 放在表达式中：c++: 先赋值再运算

int c=10;  
int d=c++;  
System.out.println(c);// 11  
System.out.println(d);// 10

6.3.2 面试题

public static void main(String[] args) {  
    int x = 10;  
    int y = ++x;        // x = 11  y = 11  
    int z = y--;        // z = 11  y = 10  
	System.out.println(x);// 11  
	System.out.println(y);// 10  
	System.out.println(z);// 11 
    System.out.println("------------------------");  
    int a = 3;  
    //       ++a=4  a++=4  a*10=50  
    // 运算顺序：从左到右  
    int b = (++a) + (a++) + (a * 10);  
    /*  
    * ++a → 先加再用：++a=4  
    * a++ → 先用再加：a++=4  
    * */    System.out.println(a);      // 5  
    System.out.println(b);      // 58  
}

6.4 类型转换

类型转换分为：隐式转换（自动类型转换）和强制类型转换

6.4.1 隐式转换

隐式转换：从低精度到高精度，即把一个取值范围小的数值或者变量，赋值给另一个取值范围大的变量。
取值范围小的数据和取值范围大的数据做运算时，会自动将小的数据类型转换为大的数据类型，然后在再进行计算

int a = 10;  
double b = a;  
System.out.println(b);// 10.0

简单记：小的给大的赋值可以直接赋值
数据从 10 变化为了 10.0 数据发生了转换，转换的过程是内部隐藏的，所以称为隐式转换

注意：byte，short，char在做运算时会自动提升为int类型

byte c = 10;  
short s = 20;  
int result = c + s;  
System.out.println(result);// 30

6.4.2强制类型转换

强制类型转换：把一个取值范围大的变量赋值给一个取值范围小的变量时，需要强制类型转换，否则编译不通过
强制类型转换的语法：目标数据类型变量名 = (目标数据类型) 被赋值的数据;
注意事项：可能会造成精度丢失

double d = 10.5;  
int j = (int) d; // 强制类型转换，从高精度到低精度  
System.out.println(j);// 10

6.4.3 面试题

阅读代码, 分析是否存在错误, 如果有请说明原因并改正.

byte b1 = 3;

byte b2 = 4;

byte b3 = b1 + b2;

public static void main(String[] args) {  
    // 存在错误：  
    // 原因: b1和b2是两个byte类型的数据, 相加的时候会直接提升为int, 提升之后就是两个int相加  
    //                结果还是int这里将int类型的结果, 赋值给byte类型的变量  
    //                属于大的给小的赋值, 不能直接赋值, 需要强转, 或者改变类型.  
    //修改：  
    byte b1 = 3;  
    byte b2 = 4;  
    byte b3 = (byte) (b1 + b2);// 也可修改为 int b3 = b1 + b2;    System.out.println(b3);  
}

6.5 赋值运算符

赋值运算符分为两大类：基本赋值运算符和复合赋值运算符
基本赋值运算符：=
符合赋值运算符：+=、-=、*=、/=、%=

示例代码如下：

public static void main(String[] args) {  
    // 赋值运算符分为两大类：基本赋值运算符和复合赋值运算符  
    //基本赋值运算符：=  
    int a = 10;  
    //复合赋值运算符：  
    // +=：加后赋值  
    // -=：减后赋值  
    // *=：乘后赋值  
    // /=：除后赋值  
    // %=：取余后赋值  
    a += 10; // 等价于 a = a + 10;    System.out.println(a);  
    a -= 10; // 等价于 a = a - 10;    System.out.println(a);  
    a *= 10; // 等价于 a = a * 10;    System.out.println(a);  
    a /= 10; // 等价于 a = a / 10;    System.out.println(a);  
    a %= 10; // 等价于 a = a % 10;    System.out.println(a);  
}

注意：扩展赋值运算符自带强转效果，不需要手动强转

int a = 10;  
double b = 20.5;  
//扩展赋值运算符自带强转效果，不需要手动强转  
a += b; // 等价于 a = (int)(a + b);
System.out.println(a);// 30
//输出结果为30，因为相加之和的30.5赋值给 a ，a 变量为 int 类型，强转后砍掉小数点，结果为30

6.6 关系运算符

关系运算符：>、 < 、>=、 <=、 ==、 !=、
示例代码如下：

public static void main(String[] args) {  
    // 关系运算符：> < >= <= == !=  
    int a = 10;  
    int b = 20;  
    System.out.println(a > b); // false  
    System.out.println(a < b); // true  
    System.out.println(a >= b); // false  
    System.out.println(a <= b); // true  
    System.out.println(a == b); // false  
    System.out.println(a != b); // true  
    // 关系运算符的结果是布尔值  
    boolean c = a > b;  
    System.out.println(c); // false  
}

6.7 逻辑运算符

6.7.1 普通逻辑运算符

分类：

&：与：两边都为true，结果才为true
|：或：两边只要有一个为true，结果就为true
!：非：取反
^：异或：两边相同为false，不同为true
示例代码如下：

System.out.println("普通逻辑运算符：&、|、!、^");  
System.out.println(true & true);//true  
System.out.println(true & false);//false  
System.out.println(true | true);//true  
System.out.println(true | false);//true  
System.out.println(!true);//false  
System.out.println(!false);//true  
System.out.println(true ^ true);//false  
System.out.println(true ^ false);//true  
System.out.println(false ^ true);//true  
System.out.println(false ^ false);//false

6.7.2 有短路效果的逻辑运算符

&&：短路与：左边为false，右边不再运算，结果为false；左边为true，右边继续运算，结果为右边
||：短路或：左边为true,右边不再运算，结果为true；左边为false，右边继续运算，结果为右边

System.out.println(true && true);//true  
System.out.println(true && false);//false  
System.out.println(false && true);//false  
System.out.println(false && false);//false  
System.out.println(true || true);//true  
System.out.println(true || false);//true  
System.out.println(false || true);//true  
System.out.println(false || false);//false

示例代码

public static void main(String[] args) {  
    int a = 10;  
    int b = 20;  
    //&&：短路与：左边为false，右边不再运算，结果为false；左边为true，右边继续运算，结果为右边  
    //++a > 30：false；  
    //--b < 20：true；  
    boolean result = ++a > 30 && --b < 20;  
    System.out.println("result=" + result);//false  
    System.out.println("a=" + a);//11  
    System.out.println("b=" + b);//20  
    //结果解释：result=false，因为++a>30的结果为false，但是因为&&短路效果，所以不会执行--b<20  
    //所以a=11，b=20  
    //||：短路或：左边为true,右边不再运算，结果为true；左边为false，右边继续运算，结果为右边  
    result = ++a > 30 || --b < 20;  
    System.out.println("result=" + result);//true  
    System.out.println("a=" + a);//12  
    System.out.println("b=" + b);//20  
    //结果解释：result=true，因为++a>30的结果为false，继续运算右边，执行--b<20，结果为true  
    //所以a=12，b=19  
}

6.8 三元运算符（三目运算符）

作用 : 根据判断条件, 从两份数据中二者选其一
三元运算符（三目运算符）：格式（条件表达式）？值1：值2；
示例代码

public static void main(String[] args) {  

	//执行流程: 
	//首先计算 判断条件的值 
	//如果值为true, 值1 就是运算结果 
	//如果值为false, 值2 就是运算结果
    int a = 10;  
    int b = 20;  
    int max = (a > b) ? a : b;  
    System.out.println("max=" + max);  
}

6.9 运算符的优先级

示例代码：

public static void main(String[] args) {  
    // 运算符的优先级：先乘除后加减，有括号先算括号内的  
    int a = 10;  
    int b = 20;  
    //结果解释：先算括号内的，(a > b || a < b)的结果为true，计算右边，a > b的结果为false，所以整个表达式的结果为false  
    System.out.println( (a > b || a < b) && a > b);//false  
    //结果解释：先算括号内的，a < b 的结果为 true，a > b 的结果为 false，true && false 的结果为 false，再与左边的 false 进行或运算，最终结果为 false    System.out.println(a > b || (a < b && a > b) );//false  
}

7- Scanner 键盘输入

Scanner类是Java中的一个实用工具，用于从不同来源读取输入数据。
代码案例

import java.util.Scanner;  

public class ScannerDemo {  
    public static void main(String[] args) {  
        // Scanner键盘输入需要三个步骤：  
        // 1.导入Scanner包  
        // 2.创建对象  
        Scanner scanner = new Scanner(System.in);  
        // 3.接收数据  
        System.out.print("请输入姓名：");  
        String name = scanner.next();  
        System.out.print("请输入年龄：");  
        int age = scanner.nextInt();  
        System.out.print("请输入身高：");  
        double height = scanner.nextDouble();  
        System.out.println(name + ", " + age + "岁, 身高" + height + "cm");  
    }  
}

常用方法

方法	说明
`nextInt()`	读取整数
`nextDouble()`	读取小数
`nextBoolean()`	读取布尔值
`next()`	读取字符串（遇空格停止）
`nextLine()`	读取一行字符串（可包含空格）

注意事项

next() 和 nextLine() 的区别：next() 遇到空格或换行停止，nextLine() 可以读取包含空格的整行
使用完后可调用 scanner.close() 关闭资源（可选，小程序一般不需要）

8、总结回顾

📝 核心要点速记

变量： 存储数据的容器，声明格式为「数据类型变量名 = 值；」，需遵循先声明后使用、类型匹配、作用域等 6 项核心规则
标识符： 类 / 方法 / 变量的命名符号，需符合「字母 / 数字 / 下划线 /$、不数字开头、不使用关键字、区分大小写」规则，推荐驼峰命名（常量全大写 + 下划线分隔）
数据类型： 4 类 8 种基本类型（整型 4 种、浮点型 2 种、字符型 1 种、布尔型 1 种）；整数默认 int、小数默认 double；byte/short/char 运算时自动提升为 int
运算符： 涵盖算术 / 赋值 / 关系 / 逻辑 / 三元等类型；注意自增自减的「先运算后赋值 / 先赋值后运算」、隐式 / 强制类型转换、短路逻辑运算符（&&/||）的特性

🔥 高频问题

Q：变量定义时可以不赋初始值吗？
A：可以，但使用变量前必须完成赋值，否则编译报错；同时变量仅在所属的 {} 范围内有效，超出作用域无法访问。
Q：byte/short 类型做运算时为什么会自动转为 int？
A：Java 为避免小范围数值运算时的精度丢失，规定 byte/short/char 这类低字节类型运算时，会统一提升为 int 类型后再计算。
Q：&& 和 &、|| 和 | 的核心区别是什么？
A：&&（短路与）左边为 false 时右边表达式不执行，||（短路或）左边为 true 时右边表达式不执行；而 & 和 | 无论左边结果如何，都会执行右边表达式，无短路效果。
Q：强制类型转换可能带来什么问题？
A：强制转换是「高精度→低精度」的转换方式，可能造成精度丢失（如 double 10.5 强转为 int 会变成 10），需谨慎使用。

📚 系列文章导航

【JavaSE 从 0 到 1】系列（连载中 3/17 篇）

🔹 环境搭建篇

✅ [第 1 篇] 还在卡 Java 环境？10 分钟搞定 JDK 配置的保姆级教程
✅ [第 2 篇] Java 开发必备：JDK 多版本共存与切换，一篇就够

🔹 语法基础篇（ upcoming）

✅ [第 3 篇] 告别语法混乱！Java 基础语法：理清变量、数据类型与运算符← 当前这篇
[第 4 篇] 变量、数据类型与运算符（待发布）

🔹 流程控制篇（upcoming）

🔹 面向对象篇（upcoming）

💬 互动区

来聊聊你的踩坑经历：

你在配置 Java 环境时遇到过什么问题？最后怎么解决的？
你现在用的是哪个 JDK 版本？为什么选它？
如果这篇文章帮到了你：

👍 欢迎点赞 + 收藏，方便随时查阅
🔄 转发给一起学 Java 的小伙伴
➕ 关注我，不错过后续的每一篇实战笔记
我们一起完成这 5.5 个月的 AI 开发学习之旅！💪

📄 版权说明

作者：木圭
首发平台：掘金 / 微信公众号「木圭学编程」
转载请联系作者，注明出处
学习笔记仅供参考，欢迎指正错误