第一阶段 JAVA 基础知识
第二章 Java 基础语法知识
在我们开始讲解程序之前，命名规范是我们不得不提的一个话题，虽说命名本应该是自由的，但是仍然有一定的“潜规则”，通过你对命名的书写，别人一眼就能看出你是不是一个“行家”。我们先来看一下有哪些规则。
| A：包名： | 全部小写用. 隔开 eg：com.ideal.www |
|---|---|
| B: 类名 或接口： | 类的首字母大写。如果类名由若干个单词组成，那么每个单词首字母大写。 |
| C: 方法 或变量名： | 所有的方法名都应该小写字母开头。如果方法名 含有若干个单词，那么其后每个单词首字母大写。 |
| D: 常量名： | 全部大写 用 _ 隔开 |
| E：原文件名： | 原文件名必须和类名相同 类名.java |
|---|---|
| F: 主方法入口： | 所有的 Java 程序由 public static void main(String []args)方法开始执行。 |
我们暂时对于这些名词还没有什么概念，但是对于我们前一篇所写到的 HelloWorld 例程来说，我们就用到了 类名、主方法这两点。
HelloWorld 作为类名自然需要满足首字母大写，又由于 HelloWorld 由两个单词组成，所以两个单词首字母分别大写。
2.1 关键字
(1)被 Java 语言赋予特定含义的单词，他们有着特定的使用位置和方式
(2)特点：
全部小写。
(3)注意事项：
A:goto 和 const 作为保留字存在。
B: 类似于 Notepad++、sublime 等编辑器对关键字有特殊颜色标记
（这是两款和好用的编辑器，可以简单的理解为可以使代码带着好看色彩的高级记事本）
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩充, 继承 | |
| final | 最终值, 不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地，原生方法（非 Java 实现） | |
| new | 新, 创建 | |
| static | 静态 | |
| strictfp | 严格, 精准 | |
| synchronized | 线程, 同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供 switch 选择 | |
| continue | 继续 | |
| default | 默认 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类, 超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 | |
| null | 空 |
2.2 标识符
(1)就是给类，接口，方法，变量等 起名字 的字符序列
(2)组成规则：
A: 首字符：字母（A-Z、a-z）、美元符（$）、下划线（_）
B: 首字符之后：字母（A-Z、a-z）、美元符（$）、下划线（_）或者 数字 的任何字符组合
(3)注意事项：
A: 不能以数字开头
B: 关键字不能作为标识符
C: 区分大小写
2.3 注释
(讨厌写自己写注释，讨厌别人不写注释 ~）
注释就是为了方便自己或别人后期阅读这部分代码的提示，能够快速的让阅读者，了解这部分代码的作用。
(1)注释就是对程序进行解释说明的文字（不会被编译运行）
(2)分类：
A: 单行注释 // + 内容
B: 多行注释 /* 内容 */
C: 文档注释 /* / 被 javadoc 工具解析成一个说明书，后期会讲到
在我们前期的学习中，只需要掌握基本的 单行注释 和多行注释 即可
注释规范：
1、类注释 注释模板如下：
/**
* Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
* FileName: Test.java
* 类的详细说明
*
* @author 类创建者姓名
* @Date 创建日期
* @version 1.00
*/
2、属性注释 注释模板如下：
/* 提示信息 /private String strMsg = null;
3、方法注释 注释模板如下：
/**
* 类方法的详细使用说明
*
* @param 参数 1 参数 1 的使用说明
* @return 返回结果的说明
* @throws 异常类型. 错误代码 注明从此类方法中抛出异常的说明
*/
4、构造方法注释 注释模板如下：
/**
* 构造方法的详细使用说明
*
* @param 参数 1 参数 1 的使用说明
* @throws 异常类型. 错误代码 注明从此类方法中抛出异常的说明
*/
5、方法内部注释 在方法内部使用单行或者多行注释
（根据实际情况添加）注释模板如下：
// 背景颜色 Color bgColor = Color.RED
2.4 常量
(1) 常量就是在程序执行的过程中，其值不发生改变的量（例如 π、重力加速度，光速等）
而在 Java 中我们使用 final 关键字来修饰常量
Eg：final double PI = 3.1415927
习惯：虽然常量名也可以用小写，但为了便于识别，通常使用大写字母 表示常量(随大流就好啦)
(2)分类：
A: 字面值常量
B: 自定义常量
字面值常量：
C++ primer：像 42 这样的值，在程序中被当作字面值常量：字面值是因为仅能用它的值称呼它，常量是因为它的值不能修改。每个字面值都有相应的类型，例如：0 是 int 型，3.14159 是 double 型。字面值仅存在于内置类型，没有类类型的字面值。因此，也没有任何标准库类型的字面值
简单理解：例如 int a = 6; 它的字面值就是 a，它的实际值是 6
(3)字面值常量
A: 字符串常量 “bwh”
B: 整数常量 666,888
C: 小数常量 123.456
D: 字符常量 ‘a’,’Z’,’0′
E: 布尔常量 true,false
F: 空常量 null
(4)在 Java 中针对整数常量提供了四种表现形式
A: 二进制 由 0，1 组成。以0b 开头。
B: 八进制 由 0，1，…7 组成。以 0 开头。
C: 十进制 由 0，1，…9 组成。整数默认是十进制。
D: 十六进制 由 0，1，…9,a,b,c,d,e,f(大小写均可) 组成。以0x 开头。
A：常见进制
常见进制的转化：
常见进制 → 十进制：忽略前缀和 0，对 1 进行运算
0b10101（二进制）
= 12^4 + 12^3 + 1*2^0
= 16 + 14 + 1
= 21
0123（八进制）
= 18^2 + 28^1 + 3*8^0
= 64 + 16 + 3
= 83
0x3c（十六进制）
= 316^1 + 1216^0
= 48 + 12
=60
十进制 → 常见进制：
除基取余，直到商为 0，余数反转。（转换几进制就将基数除以几）
其他进制的转换可以通过十进制这个中间进制进行转换
熟悉 2 的倍数对我们也是很有帮助的
B: 补充：补码、原码、反码
为什么我们要学习这些呢？首先我们要知道，在计算机内，有符号数有三种表示方法，源码、反码、和补码。而 所有的数据运算都是采用补码进行的。它的重要性可想而知。
1、原码：二进制点表示法，最高位为符号位，“0”表示正，“1”表示负，其 余位置表示数值大小，可直观反映出数据的大小。
2、反码：解决负数加法运算问题，将减法运算转换为加法运算，从而简化运算规则。
3、补码：解决负数加法运算正负零问题，弥补了反码的不足。
7 的二进制：111
| 原码 | 正数的原码最高位是 0 负数的原码最高位是 1 其他的是数值位 | |
|---|---|---|
| 符号位 | 数值位数 | |
| +7 | 0 | 0000111（补够 8 个字节，在左面补 4 个 0） |
| -7 | 1 | 0000111 |
| 反码 | 正数的反码与原码相同负数的反码与源码符号位相同，数值位取反 1 → 0、0 → 1 | |
|---|---|---|
| 符号位 | 数值位数 | |
| +7 | 0 | 0000111（补够 8 个字节，在左面补 4 个 0） |
| -7 | 1 | 1111000 |
| 补码 | 正数的补码与原码相同负数的补码是在反码的基础上 +1 | |
|---|---|---|
| 符号位 | 数值位数 | |
| +7 | 0 | 0000111（补够 8 个字节，在左面补 4 个 0） |
| -7 | 1 | 1111001 |
2.5 变量
我们刚介绍了什么是常量，那么什么是变量呢，顾名思义，变量就是在某个范围内可以变化的量 ，其实它就是一个被你所定义的变量， 在一个数据类型的约束下，可以在数据类型所允许的范围内进行，被赋值，运算，等操作。
（变量可以不在定义的时候就赋初始化值，但是在 运行编译时，如果被编译变量仍没被赋值，则是没有意义的，编译器将会报错）
格式：数据类型 变量名 = 初始化值
注意：可以在一行中声明多个变量，但是我们不推荐这种方式。
逐一声明变量能提高程序的可读性
变量类型：
· 局部变量
· 实例变量
· 类变量（静态变量）
局部变量：定义在 方法、构造方法、或者语句块中 的变量
（生而带来 死而带去 只能活在自己的世界）
只能在一定范围内使用的变量，随着这个方法等的结束变量也就无效了
对于局部变量的理解，刚入门可能也不会太深，等后面几篇我们学习到方 法后，再回过头来看这部分内容，就会有一种明了的感觉。
实例变量：声明在类中，但在方法、构造方法和语句块之外
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见
暂时在学习基础语法知识的时候可以 暂时忽略 实例变量这部分内容，这部分内容主要被使用在 面向对象 的部分，但是 极其重要。
过了很久，你也不愿回头看，学习的进度就会很慢~
类变量：后期补充
2.6 数据类型
❤ 2.6.1
Java 是一种强类型的语言，针对每一种数据都定义了明确的数据类型（就是将一些值的范围做了约束，从而为不同类型的值在内存中分配不同的内存空间）
注意：在此部分暂时不用深究引用类型，着重认熟悉一下基本数据类型，引用类型在面向对象的部分会详细解释。
我们来看一下 八种基本数据类型 的详细说明：
| Name | Size* | Range* | |
|---|---|---|---|
| byte | 1byte\ | 8bit | 存放的数据范围是 -128~127 之间 |
| short | 2bytes\ | 16bit | 最大数据存储量是 65536，数据范围是 -32768~32767 之间。 |
| int | 4bytes\ | 32bit | 数据范围是负的 2 的 31 次方到正的 2 的 31 次方减 1。 |
| long | 4bytes\ | 64bit | 数据范围为负的 2 的 63 次方到正的 2 的 63 次方减 1。 |
| float | 4bytes\ | 32bit | 数据范围在 3.4e-45~1.4e38，直接赋值时必须在数字后加上 f 或 F |
| double | 8bytes\ | 64bit | 数据范围在 4.9e-324~1.8e308，赋值时可以加 d 或 D 也可以不加。 |
| boolean | 只有 true 和 false 两个取值。 | ||
| char | 2bytes | 存储 Unicode 码，用单引号赋值。 |
注意：
- 整数默认是 int 类型
声明 long 型常量的时候长整数要加 L 或者 l
如：long l = 66666666666666L// 否则报错
- 浮点数默认是 double（双精度浮点型）
声明 float 型（单精度的浮点数）要加 F 或者
如：double d = 521.1 // 正确 float f = 52.1f // 必须加 f
- boolean 一般用来进行逻辑运算→流程控制中
- Byte、short 类型被赋值时，其实接收的是一个 int 类型的值，不 在范围内即报错
- 一个中文字符占据两用字节，Java 中字符可以存储一个汉字，是 因为 Java 字符采用Unicode 编码，每个字符占用两个字节。
- Java 中提供了三个特殊的浮点数值，正无穷大（正数除以 0），负无穷大（负数除以 0），NaN（不是一个数字,0 除以 0，负数开根号）
❤ 2.6.2 数据类型转换
一般来说，我们在运算的时候，要求参与运算的数值类型必须一致
（1）默认转换（从小到大的转换）—自动类型转换
A：byte，short, char（→ int → long → float → double）
B：byte，short, char 相互之间不转换
他们参与运算首先转换为 int 类型
疑惑：为什么 float（4 个字节）在 long（8 个字节）后面
A: 它们底层的存储结构不同
B: float 表示的数据范围比 long 范围要大
long：2^63-1
float：3.410^38 > 210^38 > 28^38 > 22^3^38
= 2*2^144 > 2^63 -1
例子一：低精度 byte 到高精度 int 会根据默认转换，自动转换类型
例子二：高精度 int 到低精度 byte 可能会损失精 度
byte 数据类型是 1 个字节、8 位
int 数据类型是 4 个字节、32 位
但是有没有办法能够让我们输出这种运算的结果呢？这就需要我们用到强制类型转换的知识。
（2）强制类型转换
格式：目标数据类型 变量 =（目标数据类型）（被转换的数据）
注意：不要随便的去用强制转化，因为它隐含了精度损失的问题
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
例子：
int i = 128;
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为 127，所以当 int 强制转换为 byte 类
型的时候，值 128 就会导致溢出
很经典的题目 1：永远做不对系列
第一句：byte 类型的 b1 ,b2 相加 自动类型转换为 int 型
int 类型的（b1 + b2）赋值给 byte 类型的 b
属于大单位转换为小单位 可能造成精度损失
第二句：3 和 4 为常量，编译过程中 先把结果计算出来，
然后看是否在 byte 的范围内，如果在就不报错
总结：
变量相加，会首先看类型问题，最终把结果赋值也会考虑类型问题
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错
很经典的题目 2：永远不会做系列
求输出结果：
分析过程：
我们想要知道结果是什么，就应该知道是如何计算的
而我们又知道 计算机中数据的运算都是补码进行的
得到补码，首先要计算出数据的二进制
A: 求出 130 的二进制 10000010
130 是一个整数 所以补齐 4 个字节（一个字节 8 位）
0000000 00000000 00000000 10000010
B: 做截取操作，截成 byte 类型的了
10000010
这个结果是补码
C 已知补码求原码。
| 符号位 | 数值位 | |
|---|---|---|
| 补码： | 1 | 0000010 |
| 反码： | 1 | 0000001 |
| 原码 | 1 | 1111110 |
| 11111110 转换为十进制为 -126 |
2.7 字符
字符 是指在计算机中所使用的 字母、数字、汉字、和符号，表示时用单引号包含在内。
例如：‘5’‘R’‘。’均是字符
在内存中，字符数据以 ASCII 码存储，即以整数表示
需要记忆的常见字符‘a’→ 97‘A’→ 65‘0’→ 48
其余字符依次递推即可
一种特殊的字符——转义字符
转移字符 = 转义 + 字符 → 转变含义的字符（不再是本来字符的意思）
结构： + 一些特定的字母
其中 n（换行）和 t（制表符）最为常用
（一）下面两种输出变量 love 的方法均有换行效果
补充：r 和 n 的区别
回车 r 意思是 光标重新回到本行的开头
换行 n 光标移动到下一行 ， 不一定是行首, 取决于其后是否还有内容
（因为我们常用在一行的句末，所以会误以为会在下一行的行首）
针对不同系统的换行符：
苹果系统 Mac n
Unix、Linux 系统 n
Windows 系统 rn
在 windows 中，如果在两端字符串的中间使用转义字符，只有使用 rn 才能真正的达到了我们日常操作中，回车换行的那种效果。
（二） t 是补全当前字符串长度到 8 ，最少 1 个，最多 8 个空格
所以灵活的使用制表符可以达到对齐两行数据的作用
2.8 字符串
字符串是由零个或者多个字符组成的有限序列，它是编程中表示文本的数据类型
字符串使用的时候用双引号括起来
String 并不是 Java 中的基本方法，而是一个类。
我们在此部分不做过多的介绍，但要知道，String 类是一个非常非常重要的类！！！
我们会在后面有专门一大篇介绍
总结：
字符串和其他数据做加法运算的时候，结果是字符串类型。
这里的 + 不是加法运算，而是字符串连接符
2.9 运算符
算数运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三目运算符
01
❤ 2.9.1 算数运算符：+ – * / % ++ —
A: 整数相除只能得到整数（想得到小数 需将其中任意的一个数据变成浮点 数）
Eg：int x = 3;
int y = 4;
System.out.println(x/y); →System.out.println(x * 1.0 / y);
B: /除法求商 %除法取余
C: ++, — 就是对变量进行自增 1 或者自减 1. 参与运算 前置后置有区别
来一道例题，大家就整明白了：
Eg : int x = 4;
int y = (x++) + (++x) + (x * 10);
System.out.println(y);
// 首先 x 后置 ++ 所以括号 1 中 x 运算时取 4 然后自增为 5
其次 x 前置 ++ 所以括号 2 中 x = 6
最后 x 10 = 6 10 = 60
Output y → 4 + 6 + 60 = 70
❤2.92 赋值运算符
基本的赋值运算符：=
扩展的赋值运算符：+=，-=，*=，/=，%=
在刚开始的时候我们书写赋值语句，还是推荐使用 基本的方法，待到日后熟练，再转为扩展的赋值语句
很经典的题目 1：你猜到底对不对
编译第一个语句报错：
编译第二个语句没有报错：（? ? ?）
扩展的赋值运算符其实隐含了一个强制类型转换
s += 1；不是等价于 s = s + 1 而是等价于 s = (s 的数据类型)（s + 1）;
❤*2.9.3 关系运算符 ==, != , > , >= , < , <=
== 无论你的操作是简单还是复杂木结构是 boolean 类型
Output → flase
❤2.9.4 逻辑运算符 & | && ||！
逻辑运算符用于连接布尔型表达式，在 java 中。不可以写成 3 < x < 6 应该写 成 x > 3 & x < 6
&& 和 & 的区别？同理 || 和 | 的区别
A：最终结果一样
B：&& 具有短路作用。左边是 false，右边不执行。（&& 效率更高）
eg：int x = 3；int y = 4；
boolean b1 = (( x++ = 3) ) && (y++ = 4)
结果：x = 4，y = 4，true
❤2.9.5 位运算符
（3 & 4）（3 | 4）（3 ^ 4）（~3）（3 << 2）（>>）（>>>）
因为是位运算，所以我们需要把数据换算成二进制
^ 的特点：一个数据对另一个数据位异或两次，该数本身不变
很经典的题目 1：交换两个整型数的值
做一个灵活的交换者
· 我们先直接给出位运算的结论
这是详细的运算过程，但是我们使用时直接用结论即可
题目：
请用最有效率的方式写出计算 2 乘以 8 的结果？
2 * 8
2 << 3
❤2.9.6 三目运算符
这一部分要与下面马上要学习的 if 语句进行对照学习
满足表达式则执行冒号前的表达式，反之则时候后面的
格式：（条件表达式）？（条件真的表达式）：（条件假的表达式）
条件表达式：结果是一个 boolean 型
Eg：将 a,b 中的较小数赋值给 x
x = a < b ? a : b → if (a < b) x = a; else x = b
2.10 键盘录入
我们之前所写的程序中，数据的值都是固定的，在源码中就写好的，而我们有时候想要让用户来决定一些值的具体数据（例如：学生成绩录入），所以键盘录入就是让用户输入一些值，使得程序更加灵活。
现在我们对于导包以及对象的概念仍然比较模糊，但是我们在介绍别的知识的时候也会频繁的用到，所以大家暂时按照以下的格式记忆下来。
A：导包：
格式：import java.util.Scanner;
位置：在 class 上面
B：创建键盘录入对象
格式：Scanner sc = new Scanner(System.in);
C: 通过对象获取数据
格式：int x = sc.nextint();
String s = sc.nextLine();（字符串录入）
2.11 选择结构（分支结构）
· if 语句
· switch 语句
认识选择结构后我们的程序就会变得很有趣了，我们先来学习一下最常见的 If 条 件语句
（一）if 语句
更正：满足就执行，不满足就出去
我们对照三元运算符和 if 语句，这两个是不是完全一样的呢？
三元运算符的操作都可以使用 if 语句改进，反之不成立
什么时候不成立呢？
当 if 语句控制的语句体是一条输出语句的时候，就不成立。
因为三元运算符是一个运算符，必须要求有一个结果返回。
而输出语句却不能作为一个返回结果
三个数中求最大值：可以用三目运算 跳转 2.9.6
用 if 语句实现：
（二）switch 语句
注意： ·case 后面只能是常量，不能是变量，而且不能出现相同的
·default 可以省略 但是一般不建议，
（除非判断的值是固定的，单选题）
·break 可以省略，一般不建议
·default 可以出现在 switch 语句的任意位置
·switch 语句的结束条件：
遇到 break 或者 执行到程序的末尾
以下条件选用 switch
·条件分支有多个
·条件的值是整数或一个字符型
原因
·如果条件分支太多时用 if 语句，一定会出现 if 的嵌套，if 嵌套的越多，程序 的开销就会随着增大，这样整个程序的运行效率就一定会大大降低
·switch 值比较一次就可以找出条件的结果
我们在下面将上面的 if 成绩例程改为 switch 版本是不是简洁了很多呢
2.12 循环语句
· for 循环
· while 循环
· do …while 循环
我们如果存在大量的重复语句，我们就可以使用循环语句，进行处理。
（一）for 循环
for 语句不仅适用于循环次数明确的情况，也适用于循环次数不明确的情况 （满足条件继续循环，不满足跳出循环）
求偶数和还有一种方法：
for (int x =0; x <= 100; x+=2){
Sum += x
}
求 5 的阶乘
// 分析 什么是阶乘 n! = n * (n -1) (n – 2) … 3 2 *1
int jc = 1; // 定义最终结果变量
for (int x = 1; x <= 5; x++){
Jc *= x
}
在控制台输出所有的水仙花数
// 水仙花数就是指一个三位数，其各位数字的立方等于该数本身
Eg：153 = 1*11 +555+ 33*3 = 125 +27 =153
通过 for 循环我们可以实现获取一个三位数
获取这个三位数的个十百位上的数据
获取方法：假设有一个数据为 153
Ge：153 % 10 =3
Shi：153 / 10 % 10 = 5
Bai：153 / 10 / 10 % 10 = 1
Qian：x/10/10/10%10
Wan：x/10/10/10/10%10
利用嵌套循环：可以输出各种样式的三角形
外循环控制行数，内循环控制列数
System.out.print(“* ”) → 不换行
System.out.println() → 换行
九九乘法表
（二）while 循环
判断条件表达式的值为逻辑真时，重复执行循环体（不满足出去）
死循环：
第一种：
for(;;){}
第二种：
while(true){}
While 循环和 for 循环的区别？
使用区别：
for 循环 控制条件定义的变量，只能在循环内使用
while 循环 ….. 可以在循环外使用
因为变量及早的从内存中消失，可以提高内存的使用效率
另一种理解：
for 语句不仅适用于循环次数明确的情况，也适用于循环次数不明确的情况
while 循环适用于循环次数不明确的情况
（三）do … while 循环
先执行循环体，再判断继续条件不为逻辑真时，再执行循环体并判断条 件，直到条件为假转去执行 while 下面的语句（不满足出去）
至少要执行一次
2.12 跳转控制语句
·break：中断
·continue: 继续
·return: 返回
（一）break 的意思是 中断
适用：switch、循环语句中(循环语句中加入了 if 判断的情况)
跳出单层循环（从最近的封闭循环体中跳出）
若想跳出多层循环 需要使用带标签的语句
格式：标签名：语句
（二）continue 继续 的意思是
跳出一次循环进入下一次的执行
（结束本次循环，进入下次循环的判定。）
（三）retuen
return 关键字不是为了跳出循环体，更常用的功能是 （结束一个方法）， 也就是退出一个方法。跳转到上层调用的方法。
结尾：
如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家！^_^
如果能帮到你的话，那就来关注我吧！
在这里的我们素不相识，却都在为了自己的梦而努力 ❤
一个坚持推送原创 Java 技术的公众号：理想二旬不止