目录
- 1 基础语法
- 1.1 Hello World
- 1.2 常量
- 1.3 数据类型
- 1.4 String
- 1.5 StringBuilder
- 1.6 运算符
- 1.7 位运算符
- 1.8 逻辑运算符
- 1.9 关系运算符
- 1.10 练习：计算数字和
- 1.11 关键字和语句
- 1.12 流程控制
- 1.13 数组
- 1.14 用户输入操作
- 参考代码
1 基础语法
1.1 Hello World
每门语言学习前，都会有一个 HelloWorld 的示例，Java 当然也不例外。Java 中所有的代码都必须包含在 class 中，main 方法是程序的入口，并且 Java 是区分大小写的。
我们创建 HelloWorld.java ，内容如下：
public class HelloWorld {public static void main(String[] args) {System.out.println("Hello World!");}
}
执行下面shell命令进行编译：
!javac HelloWorld.java
会在同级目录下生成对应 class 文件。执行下面 shell 命令进行运行：
!java HelloWorld
Hello World!
1.2 常量
常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量，只是它们在程序的运行过程中是不允许改变的。
Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。
// final 数据类型 常量名 = 值;
final double PI = 3.14;
或者先声明变量，再进行赋值：
final int FINAL_VARIABLE;
FINAL_VARIABLE = 100;
创建 FinalVar.java 文件，并编译运行。
public class FinalVar {public static void main(String[] args){final String FINAL_STRING = "MangoGO";System.out.println(FINAL_STRING);}
}
!java FinalVar.java
MangoGO
1.3 数据类型
Java 中一共八种基本数据类型，下表列出了基本数据类型的数据范围、存储格式、默认值和包装类型等。
| 数据类型 | 默认值 | 存储格式 | 数据范围 | 包装类型 |
|---|---|---|---|---|
| short | 0 | 2 个字节 | -32,768 到 32,767 | Short |
| int | 0 | 4 个字节 | -2,147,483,648 到 2,147,483,647 | Integer |
| byte | 0 | 1 个字节 | -128 到 127 | Byte |
| char | 空 | 2 个字节 | Unicode 的字符范围：\u0000（即为 0）到 \uffff（即为 65,535） | Character |
| long | 0L 或 0l | 8 个字节 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | Long |
| float | 0.0F 或 0.0f | 4 个字节 | 32 位 IEEEE-754 单精度范围 | Float |
| double | 0.0 或 0.0D(d) | 8 个字节 | 64 位 IEEE-754 双精度范围 | Double |
| boolean | false | 1 位 | true 或 false | Boolean |
- 整数
byte、short、int、long 四种基本数据类型表示整数，需要注意的是 long 类型，使用 long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。 - 浮点数
float 和 double 类型表示浮点数，即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。 - char 类型
char 类型用于表示单个字符。需要将字符用单引号括起来char a = ‘a’，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = ‘\u0061’。 - boolean 类型
boolean 类型（布尔类型）用于表示真值 true或者假值 false，Java 中布尔值不能和整数类型或者其它类型互相转换。
1.4 String
Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。String 对象的初始化格式有如下两种：
String s0 = "abc";String s1 = new String("abd")
String 类具有丰富的方法，比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。
（1）字符串长度
调用方法：字符串标识符.length(); 返回一个 int 类型的整数（字符串中字符数，中文字符也是一个字符）。例如：
String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length(); // 3
int len2 = s2.length(); // 6
（2）字符串比较
equals() 方法，该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，否则返回 false。
equals() 方法比较是从第一字符开始，一个字符一个字符依次比较。
如果想忽略掉大小写关系，比如：java 和 Java 是一样的，可以调用 equalsIgnoreCase() 方法：
String s = new String("Java");
String m = "java";
System.out.println(s.equals(m)); // false
System.out.println(s.equalsIgnoreCase(m)); // true
而使用 “==” 比较的是两个对象在内存中存储的地址是否一样。
String s1 = "abc";
String s2 = new String("abc");
boolean b = (s1 == s2); // false
（3）字符串连接
字符串连接有两种方法：
- 使用 +，比如 String s = "Hello " + “World!”。
- 使用 String 类的 concat() 方法。
String s0 = new String("Hello ");
String s1 = "World" + "!"; // +号连接
String s2 = s0.concat(s1); // concat()方法连接
System.out.println(s2);
（4）字符串索引
charAt() 方法的作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。
String s = "abc";
char c = s.charAt(1); // 6
（5）字符串提取
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| indexOf(char ch) | int | 搜索字符 ch 第一次出现的索引 |
| indexOf(String value) | int | 搜索字符串 value 第一次出现的索引 |
| lastIndexOf(char ch) | int | 搜索字符 ch 最后一次出现的索引 |
| lastIndexOf(String value) | int | 搜索字符串 value 最后一次出现的索引 |
| substring(int index) | String | 提取从位置索引开始到结束的字符串 |
| substring(int beginindex, int endindex) | String | 提取 beginindex 和 endindex 之间的字符串部分 |
| trim() | String | 返回一个前后不含任何空格的调用字符串的副本 |
public class StringTest {public static void main(String[] args){String s0 = new String("Java");String s1 = "java";System.out.println("用equals()比较，java和Java结果为"+s0.equals(s1));System.out.println("用equalsIgnoreCase()比较，java和Java结果为"+s0.equalsIgnoreCase(s1));String s2 = "abcdefabc";System.out.println("字符串s2："+s2);System.out.println("字符a第一次出现的位置为"+s2.indexOf('a'));System.out.println("字符串bc第一次出现的位置为"+s2.indexOf("bc"));System.out.println("字符a最后一次出现的位置为"+s2.lastIndexOf('a'));System.out.println("从位置3开始到结束的字符串"+s2.substring(3));System.out.println("从位置3开始到6之间的字符串"+s2.substring(3,6));}
}
!java StringTest.java
用equals()比较，java和Java结果为false
用equalsIgnoreCase()比较，java和Java结果为true
字符串s2：abcdefabc
字符a第一次出现的位置为0
字符串bc第一次出现的位置为1
字符a最后一次出现的位置为6
从位置3开始到结束的字符串defabc
从位置3开始到6之间的字符串def
1.5 StringBuilder
String 是无法被修改的，对 String 的修改，其实是新建了一个 String 对象。如果需要修改字符串的内容，可以使用 StringBuilder。它相当于一个存储字符的容器。
初始化格式有以下三种：
// 构造一个不包含任何字符且初始容量为 16 的 StringBuilder
StringBuilder a = new StringBuilder();// 构造一个不包含任何字符且容量为 cap 的 StringBuilder
StringBuilder b = new StringBuilder(int cap);
// 构造一个 StringBuilder，内容初始化为 str
StringBuilder c = new StringBuilder(String str);
public class StringBuilderTest {public static void main(String[] args){StringBuilder s1 = new StringBuilder();s1.append("java");StringBuilder s2 = new StringBuilder(5);StringBuilder s3 = new StringBuilder("MangoGO");System.out.println("s1:" + s1.toString() + "\tcap:" + s1.capacity());System.out.println("s2:" + s2.toString() + "\tcap:" + s2.capacity());System.out.println("s3:" + s3.toString() + "\tcap:" + s3.capacity());}
}
!java StringBuilderTest.java
s1:java cap:16
s2: cap:5
s3:MangoGO cap:23
s2:MangoGO cap:12
其中 s3 的 capacity 为 23 是因为初始容量 16 + MangoGO 的长度 7。
StringBuilder 常用方法：
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| deleteCharAt(int index) | StringBuilder | 删除 StringBuilder 中指定位置的 char |
| indexOf() | int | 返回子字符串首次出现在该字符串中的索引 |
| capacity() | int | 返回当前容量 |
| charAt(int index) | char | 返回序列中指定索引的 char 值 |
| toString() | String | 返回序列数据的 string 格式 |
1.6 运算符
| 算术运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| + | 加法 | 相加运算符两侧的值 | 双目运算符 | a + b 等于 8 |
| - | 减法 | 左操作数减去右操作数 | 双目运算符 | a - b 等于 2 |
| * | 乘法 | 相乘操作符两侧的值 | 双目运算符 | a * b 等于 15 |
| / | 除法 | 左操作数除以右操作数 | 双目运算符 | a / b 等于 1 |
| % | 取余 | 左操作数除右操作数的余数 | 双目运算符 | a % b 等于 2 |
| ++ | 自增 | 操作数的值增加 1 | 单目运算符 | ++i（或 i++） 等于 2 |
| -- | 自减 | 操作数的值减少 1 | 单目运算符 | --i（或 i--） 等于 0 |
其中，自增 (++) 和自减 (–) 运算符有两种写法：前缀（++i,–i）和后缀（i++,i–）。
- 前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
- 后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算
public class ArithmeticOperation {public static void main(String args[]) {int a = 5;int b = 3;int c = 3;int d = 3;System.out.println("a + b = " + (a + b));System.out.println("a - b = " + (a - b));System.out.println("a * b = " + (a * b));System.out.println("a / b = " + (a / b));System.out.println("a % b = " + (a % b));System.out.println("a++ = " + (a++));System.out.println("++a = " + (++a));System.out.println("b-- = " + (b--));System.out.println("--b = " + (--b));System.out.println("c++ = " + (c++));System.out.println("++d = " + (++d));}
}
!java ArithmeticOperation.java
a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4
1.7 位运算符
Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。
表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：
| 位运算符 | 名称 | 描述 | 举例 |
|---|---|---|---|
| & | 按位与 | 如果相对应位都是 1，则结果为 1，否则为 0 | （a＆b），得到 12，即 0000 1100 |
| 丨 | 按位或 | 如果相对应位都是 0，则结果为 0，否则为 1 | （ a 丨 b ）得到 61，即 0011 1101 |
| ^ | 按位异或 | 如果相对应位值相同，则结果为 0，否则为 1 | （a^b）得到 49，即 0011 0001 |
| ~ | 按位补 | 翻转操作数的每一位，即 0 变成 1，1 变成 0 | （~a）得到 -61，即 1100 0011 |
| << | 按位左移 | 左操作数按位左移右操作数指定的位数 | a<<2 得到 240，即 1111 0000 |
| >> | 按位右移 | 左操作数按位右移右操作数指定的位数 | a>>2 得到 15 即 1111 |
| >>> | 按位右移补零 | 左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充 | a>>>2 得到 15 即 0000 1111 |
public class BitOperation {public static void main(String[] args) {int a = 60;int b = 13;System.out.println("a & b = " + (a & b));System.out.println("a | b = " + (a | b));System.out.println("a ^ b = " + (a ^ b));System.out.println("~a = " + (~a));System.out.println("a << 2 = " + (a << 2));System.out.println("a >> 2 = " + (a >> 2));System.out.println("a >>> 2 = " + (a >>> 2));}
}
!java BitOperation.java
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15
1.8 逻辑运算符
逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。
表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（false）：
| 逻辑运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| && 或 & | 与 | 当且仅当两个操作数都为真，条件才为真 | 双目运算符 | (a && b) 或 (a & b) 为假 |
| | | 或 | | 或 | 两个操作数任何一个为真，条件为真 | 双目运算符 | (a || b) 或 (a | b) 为真 |
| ! | 非 | 用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假 | 单目运算符 | (!a）为假 |
| ^ | 异或 | 如果两个操作数逻辑相同，则结果为假，否则为真 | 双目运算符 | (a ^ b) 为真 |
public class LogicOperation {public static void main(String args[]) {boolean a = true;boolean b = false;System.out.println("a && b = " + (a && b));System.out.println("a || b = " + (a || b));System.out.println("!a = " + (!a));System.out.println("a ^ b = " + (a ^ b));}
}
!java LogicOperation.java
a && b = false
a || b = true
!a = false
a ^ b = true
1.9 关系运算符
关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。
| 比较运算符 | 名称 | 描述 | 举例 |
|---|---|---|---|
| == | 等于 | 判断两个操作数的值是否相等，如果相等则条件为真 | (a == b） 为 false |
| != | 不等于 | 判断两个操作数的值是否相等，如果值不相等则条件为真 | (a != b) 为 true |
| > | 大于 | 判断左操作数的值是否大于右操作数的值，如果是那么条件为真 | (a > b) 为 false |
| < | 小于 | 判断左操作数的值是否小于右操作数的值，如果是那么条件为真 | (a < b) 为 true |
| >= | 大于等于 | 判断左操作数的值是否大于或等于右操作数的值，如果是那么条件为真 | (a >= b) 为 false |
| <= | 小于等于 | 判断左操作数的值是否小于或等于右操作数的值，如果是那么条件为真 | (a <= b) 为 true |
public class RelationalOperation {public static void main(String[] args) {int a = 3;int b = 5;System.out.println("a == b: " + (a == b));System.out.println("a != b: " + (a != b));System.out.println("a > b: " + (a > b));System.out.println("a < b: " + (a < b));System.out.println("a >= b: " + (a >= b));System.out.println("a <= b: " + (a <= b));System.out.println("(a > b ? a : b) = " + (a > b ? a : b));}
}
!java RelationalOperation.java
a == b: false
a != b: true
a > b: false
a < b: true
a >= b: false
a <= b: true
(a > b ? a : b) = 5
1.10 练习：计算数字和
需要实现以下需求：
- 获取控制台输入的两个整型参数。
- 输出两个整型参数和。
比如输入 3 和 4 对应输出 7。
import java.util.Scanner;public class Sum {public static void main(String[] args) {Scanner in = new Scanner(System.in);int x1 = in.nextInt();int x2 = in.nextInt();int sum = x1 + x2;System.out.println("The sum of " + x1 + " and " + x2 + " is " + sum);}
}
Jupyter执行java代码不支持从键盘获取输入，就不演示了。
1.11 关键字和语句
- 关键字
Java 的关键字对 Java 的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。
- 方法
Java 中的方法，可以将其看成一个功能的集合，它们是为了解决特定问题的代码组合。
方法的定义语法：
访问修饰符 返回值类型 方法名(参数列表) {方法体;
}
例如：
public void functionName(Objetc arg){System.out.println("Hello World.")
}
在上面的语法说明中：
-
访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用。
-
返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void （代表无类型）；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。
-
方法名：是方法的名字，必须使用合法的标识符。
-
参数列表：是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
-
方法体：方法体包含具体的语句，定义该方法的功能。
当方法定义好之后，需要调用才可以生效，我们可以通过 main 方法（main 方法是 Java 程序的入口，所以需要用它来调用）来调用它，比如：
public class MethodDemo {public static void main(String[] args) {method();}public static void method() {System.out.println("方法被调用");}
}
!java MethodDemo.java
方法被调用
1.12 流程控制
常见主要为：条件语句、循环语句、跳转语句。
- 条件语句
语法：
if (条件表达式) {条件成立时执行的代码;
}
或者：
if (条件表达式) {条件成立时执行的代码;
}
else {条件不成立时执行的代码;
}
或者：
if (条件表达式) {代码块1;
}
else if {代码块2;
}
···
else {代码块3;
}
public class ScoreJudge {public static void main(String[] args) {int score = 78;if (score >= 60) {if (score >= 80) {if (score >= 90) {System.out.println("优秀");} else {System.out.println("良好");}} else {System.out.println("及格");}} else {System.out.println("不及格");}}
}
!java ScoreJudge.java
及格
- switch 语句
switch(表达式) {case 值1:语句块1;break;case 值2:语句块2;break;···default:默认语句块;
}```java
public class Draw {public static void main(String[] args) {int num = 2;switch (num) {case 1:System.out.println("恭喜你，获得了一等奖");break;case 2:System.out.println("恭喜你，获得了二等奖");break;case 3:System.out.println("恭喜你，获得了三等奖");default:System.out.println("很遗憾，你没有获奖");}}
}
!java Draw.java
恭喜你，获得了二等奖
- while 和 do-while 语句
while 语法：
while(条件表达式) {循环体;
}
do-while 语法：
do {循环体;
} while (条件表达式);
public class SumOfEven {public static void main(String[] args) {int i1 = 1, i2 = 1;int sum1 = 0, sum2 = 0;while (i1 <= 1000) {if (0 == i1 % 2) {sum1 += i1;}i1++;}System.out.println("用while，1到1000中，所有偶数的和为：" + sum1);do {if (0 == i2 % 2) {sum2 += i2;}i2++;} while (i2 <= 1000);System.out.println("用do-while，1到1000中，所有偶数的和为：" + sum2);}
}
!java SumOfEven.java
用while，1到1000中，所有偶数的和为：250500
用do-while，1到1000中，所有偶数的和为：250500
- for 语句
for 语法：
for (初始化表达式; 条件表达式; 迭代表达式) {循环体;
}
public class SumOfEvenWithFor {public static void main(String[] args) {int sum = 0;for (int i = 1; i <= 1000; i++) {if (0 == i % 2) {sum += i;}}System.out.println("用for循环，1到1000中，所有偶数的和为：" + sum);}
}
!java SumOfEvenWithFor.java
用for循环，1到1000中，所有偶数的和为：250500
- 跳转语句
break 关键字经常用在条件和循环语句中，用来跳出循环语句。
continue关键字的作用是跳过循环体中剩余的语句执行下一次循环。
public class Jump {public static void main(String[] args) {for (int i = 1; i <= 10; i++) {System.out.println("循环第" + i + "次");if (0 == i % 3) {break;}if (0 == i % 5) {System.out.println("我进来了！");}}for (int i = 1; i <= 10; i++) {if (0 == i % 2) {continue;}System.out.println(i);}}
}
!java Jump.java
循环第1次
循环第2次
循环第3次
1
3
5
7
9
1.13 数组
数组就是相同数据类型的元素按一定顺序排列的集合。可以把它看成一个大的盒子，里面按顺序存放了多个数据类型相同的数据。
数组中的元素都可以通过下标来访问，下标从 0 开始，到数组长度 -1 结束。
数组的声明语法：
数据类型[] 数组名;
例如：
int[] ages;
char[] symbols;
String[] names;
声明数组后，需要为数组分配内存空间，也就是定义多大的数组：
数组名 = new 数据类型[数组长度];
数组长度就是数组最多可存放元素的个数。可以在数组声明的时候初始化数组，或者在声明时就为它分配好空间，这样就不用再为数组分配空间:
int [] ages = {12, 21, 22, 32, 45}; //声明并初始化一个整型数组，有5个元素
char [] symbols = new char[10]; //声明并分配一个长度为10的字符数组
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的：
age[0] = 12;
Java 中可以将一个数组赋值给另一个数组，如:
int[] arr1 = {1, 2, 3};
int[] arr2;
arr2 = arr1;
这里只是复制了一个引用，即 a2 和 a1 是相同数组的不同名称。
public class ArrayTest {public static void main(String[] args) {int [] a1 = {1, 2, 3};int [] a2;a2 = a1;for (int i = 0; i < a2.length; i++) {a2[i]++;}for (int i = 0; i < a1.length; i++) {System.out.println(a1[i]);}}
}
!java ArrayTest.java
2
3
4
for 语句在数组内可以使用特殊简化版本，在遍历数组、集合时，foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思:
for (元素类型 变量名 : 数组名) {循环体;
}
public class JudgePrime {public static void main(String[] args) {int[] ages = {12, 18, 9, 33, 45, 60};int i = 1;for (int age : ages) {Sys1tem.out.println("数组中的第“ + i +"个元素是: " + age);i++;}}
}
!java JudgePrime.java
数组中的第1个元素是: 12
数组中的第2个元素是: 18
数组中的第3个元素是: 9
数组中的第4个元素是: 33
数组中的第5个元素是: 45
数组中的第6个元素是: 60
二维数组可以看成是一间有座位的教室，座位一般用第几排的第几个进行定位，每一个座位都有一个行和一个列的属性，一排的座位相当于一个一维数组，所以可以将二维数组简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。
数据类型 [][] 数组名 = new 数据类型[行数][列数];//或者
数据类型[][] 数组名;
数组名 = new 数据类型[行数][列数];//或者
数据类型 [][] 数组名 = {{值11, 值12, 值13, ...},{值21, 值22, 值23, ...},···
}//二维数组赋值与访问也是通过下标进行
数组名[行索引][列索引] = 值;
public class ArrayTest2 {public static void main(String[] args) {String[][] name = {{"xiaoming", "xiaohua", "xiaohong"},{"zhangsan", "lisi", "wangwu"}};for (int i = 0; i < name.length; i++) {for (int j = 0; j < name[0].length; j++) {System.out.println(name[i][j]);}}}
}
!java ArrayTest2.java
xiaoming
xiaohua
xiaohong
zhangsan
lisi
wangwu
1.14 用户输入操作
在 Java 中使用 java.util 包下的Scanner 类来获取用户的输入。使用 import java.util.Scanner; 即可导入 Scanner，使用方法示例：
import java.util.Scanner;public class ScannerDemo {public static void main(String[] args) {Scanner in = new Scanner(System.in);String s = in.nextLine();System.out.println(s);while (!in.hasNext("exit")) {System.out.println(in.nextLine());}in.close();}
}
由于jupyter中不能接收键盘输入，故不做展示。
参考代码
GitCode
系列文章专栏：
Java入门
1 基础部分 \
2 面向对象 \
3 常用类 \
持续更新中：\
