20210202-（一）JavaSE-3.Java基础语法学习

野性酷女 2022-10-26 14:10 253阅读 0赞

# 3.Java基础语法学习 #

## 3.1注释 ##

*  平时我们编写的代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
 *  注释并不会被执行，是给我们写代码的人看的。
 *  **书写注释是一个非常好的习惯。**
 *  Java的注释有三种：  
    1）单行注释 // 内容 ，用于注释一行文字  
    2）多行注释 /\* 内容 \*/ ，用于注释一段文字  
    3）文档注释 JavaDoc

/** *第一行 *第二行 */

*  创建一个空的项目，在项目中创建模块（module),再在模块下创建类文件。
 *  [有趣的代码注释][Link 1]

--------------------

## 3.2标识符和关键字 ##

1.  **标识符**

*  关键字
 *  **Java所有的组成部分都需要有名字。类名、变量名以及方法名都被称为标识符。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center]

1.  **标识符注意点**

*  所有的标识符都应该以字母（A-Z或a-z），美元符（$）、或者下划线（\_）**开始**。
 *  首字符之后可以是字母（A-Z，a-z），美元符（$）、下划线（\_）或数字的任何字符组合。
 *  **不能使用关键字作为变量名或方法名。**
 *  标识符是**大小写敏感的**。
 *  合法的标识符举例：age 、$Salary、 \_value、 \_1\_value
 *  非法的标识符举例： 123abc、-salary、 \#abc
 *  可以使用中文命名，但是不建议这样去使用，也不建议使用拼音，很Low。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 1]

--------------------

## 3.3数据类型 ##

**1. 数据类型**

*  强类型语言（Java）  
    1）**要求变量的使用要严格符合规定，所有变量都必须先定义后才可以使用。**
 *  弱类型语言
 *  Java的数据类型分为两大类  
    1）基本类型（primitive type）  
    2）引用类型（reference type）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 2]

public class demo1 { 
        public static void main(String[] args) { 
           //八大数据类型介绍
            //整数
            int num1 = 10; //最常用
            byte num2 = 20;
            short num3 = 30;
            long num4 = 30l;  //long 类型要在后面加一个L
    
            //小数：浮点数
            float num5 = 50.1f; //float 类型要在后面加一个f
            double num6 = 3.1415926325566256;
    
            //字符
            char name = '吕';
            //字符串 String 不是关键字，用于表示类
            //String name1 = "张三";
    
           //布尔型：用于表示是与否
           boolean flag = true;
           boolean flag1 = false;
        }
    }

**2. 什么是字节**

*  位（bit）：是计算机内部 **数据储存** 的最小单位，11001100是一个八位的二进制数。
 *  字节（byte）:是计算机中 **数据处理** 的基本单位，习惯上用大写B来表示。
 *  1 B（byte,字节） = 8 bit（位）
 *  字符：是指计算机中使用的字母、数字、字和符号。
 *  1 bit 表示 1位
 *  1 Byte 表示一个字节 1B=8b
 *  1024 B = 1 KB
 *  1024 KB =1MB
 *  1024 MB = 1GB
 *  1024 GB = 1TB

--------------------

## 3.4数据类型扩展及面试题解析 ##

**1. 整数拓展**

*  进制  
    1）二进制0b  
    2）八进制0  
    3）十进制  
    4）十六进制0x

public class demo2 { 
        public static void main(String[] args) { 
            //整数拓展：进制 二进制0b 八进制0 十进制 十六进制0x
            int num1 = 10; //十进制 0~9
            int num2 = 010; //八进制 0~7
            int num3 = 0x10; //十六进制 0~9 A~F
            int num4 = 0b10; //二进制 0和1
            System.out.println(num1);
            System.out.println(num2);
            System.out.println(num3);
            System.out.println(num4);
            }
      }

输出结果：  
![在这里插入图片描述][2021020312145410.png_pic_center]  
**2. 浮点数拓展**

*  先来看一个例子：

public class demo3 { 
        public static void main(String[] args) { 
            //浮点数扩展：
            //银行业务怎么表示？（钱）
            float a1 = 0.1f;     //0.1
            double a2 = 1.0/10;  //0.1
            System.out.println(a1==a2);  //false?
            System.out.println(a1);  //0.1
            System.out.println(a2);  //0.1
            System.out.println("===============");
    
            float a3 = 12134442414f;
            float a4 = a3+1;
            System.out.println(a3==a4); //true 
            System.out.println(a3);
            System.out.println(a4);
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 3]

*  为什么会有这种情况发生呢?  
    1）因为float 位数是有限的，且是离散的，存在舍入误差，大约，接近但不等于的情况。  
    2）因此**最好完全避免使用浮点数进行比较。**
 *  那么银行业务中的钱，又该如何表示呢？  
    1）不使用浮点数，而使用一个 类：BigDecimal 数学工具类  
    **3. 字符拓展**  
    我们来看一个例子：

public class demo4 { 
        public static void main(String[] args) { 
            //字符拓展
            char a1 = 'a';
            char a2 ='中';
            System.out.println(a1);
            System.out.println((int)a1); //强制转换为数值
            System.out.println(a2);
            System.out.println((int)a2); //强制转换为数值
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 4]

*  由此我们得出结论：所有的字符本质上还是数字。
 *  编码：Unicode表，里面将字符与数值相对应。比如 65=A 97=a ,0~65536 ,Excel表格，2的16次方。
 *  原来的Unicode编码，是从 U0000~UFFFF  
    比如：

char c3 ='\u0061'
    system.out.println(c3);  //结果为：a

*  **转义字符**

public class demo4 { 
        public static void main(String[] args) { 
            //字符拓展-转义字符
            System.out.println("hello\tworld"); // \t表示制表符
            System.out.println("hello\nworld"); // \n表示换行符
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 5]  
常见的转义字符表：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 6]

--------------------

## 3.5类型转换 ##

**1. 类型转换**

*  由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
 *  运算中，不同类型的数据先转换为同一类型后，再进行运算。  
    ![在这里插入图片描述][20210203130822810.png_pic_center]
 *  强制类型转换  
    如下代码：

public class demo5 { 
        public static void main(String[] args) { 
            int  i = 128;
            byte b = (byte)i; //-128~127，内存溢出的问题 强制转换，由高到低的转换。
            System.out.println(i);
            System.out.println(b);
        }
    }

输出结果：  
![在这里插入图片描述][20210203134414864.png_pic_center]

*  强制转换：使用\*\* (类型)变量名\*\*，适用于由**高到低**的转换
 *  自动转换： 无需使用，适用于由**低到高**的转换  
    如下代码：

public class demo5 { 
        public static void main(String[] args) { 
            int i1 = 128;  //低
            double d1 = i1; //高，把低转换为高
            System.out.println(i1); 
            System.out.println(d1);
        }
    }

输出结果：  
![在这里插入图片描述][20210203134948578.png_pic_center]  
**- 注意点：**  
1）不能对布尔值进行转换。  
2）不能对象类型转换为不相干的类型。  
3）在把高容量转换为低容量的时候，使用强制转换。反之，则无需操作。  
4）转换的时候可能存在内存溢出的问题，或者是精度的问题。

system.out.println((int)23.7); //23
    system.out.println((int)-45.89); //-45
    char c ='a';
    int  c1= c+1;
    system.out.println(c1);  //98
    system.out.println((char)c1);  //b

*  JDK 7的新特性：数字之间可以使用下划线\_进行分割。  
    如下代码：

int money = 10_0000_0000;
    system.out.println(money); //1000000000

public class demo6 { 
        public static void main(String[] args) { 
            //定义比较大的数值的时候，注意溢出的问题
            int money = 10_0000_0000;
            int year = 20;
            int total = money * year;
            long total1 = money * year;
            long total2 = money * ((long)year); //或者在变量定义时，在后面使用大写的L 表示long类型。如 20L;
            System.out.println(total); //total为int型，内存溢出。显示错误数据。
            System.out.println(total1); //money和year仍为int，计算结果也为int，结果就已经内存溢出为错误数据了，即使转换为 long，也是显示的错误结果
            System.out.println(total2); //把其中一个值先转换为long，计算结果为long,再输出正常的long类型的结果。
        }
    }

public class demo6 { 
        public static void main(String[] args) { 
            //定义比较大的数值的时候，注意溢出的问题
            int money = 10_0000_0000;
            int year = 20;
            **long year1 = 20L;** 
            long total3 = money * year1;
            System.out.println(total3);
        }
    }

输出结果：  
![在这里插入图片描述][20210203152711357.png_pic_center]

--------------------

## 3.6变量、常量、作用域 ##

**1. 变量**\*\*

*  变量是什么？ 变量就是可以变化的量。
 *  Java是一种强类型语言，每个变量必须声明其类型。
 *  Java变量是程序中最基本的存储单元，其要素包含变量名，变量类型和作用域。  
    定义语法：

type varName  [=value] [{ ,varName [=value]}];
    //数据类型 变量名 =值;可以使用逗号隔开来声明多个同类型变量。

*  注意事项：  
    1）每个变量都要有类型，类型可以是基本类型，也可以是引用类型。  
    2）变量必须是合法的标识符。  
    3）变量声明是一条完整的语句，因此每一个声明都必须以**分号**结束。  
    如以下代码：

public class demo7 { 
        public static void main(String[] args) { 
            //int a,b,c; 为了保证程序的可读性，不建议一次性在一行定义多个变量。
            //int a=1,b=2,c=3;
            String name = "zhangsan";
            char x = 'X';
            double pi = 3.14;
            
        }
    }

**2. 变量作用域**

*  类变量：与实例变量类似，只不过多了一个static。
 *  实例变量：位于类的内部，方法的外部，作用载大于局部变量。从属于对象（类）;
 *  局部变量：作用域最小，只在方法里生效。  
    如下代码：

public class demo8 { 
        //类变量 static，从属于 类。
        static double salary =2500;
        //属性，即变量
        //实例变量，位于类的内部，方法的外部。从属于对象（类），无须初始化值即可以使用。
        //在实例变量中，如果变量未初始化值，则使用默认值。数值型的默认值：0 或 0.0，布尔值默认为false;除了基本类型（8种），其余的默认值全部为null.
        String name;
        int age;
       //主程序方法（main方法），位于 类 内部。
        public static void main(String[] args) { 
           //局部变量,位于 方法 内部，只在方法里生效。在使用前必须先声明和初始化值。
           // int i; 未初始化值，无法进行输出。
            int i =10;
            System.out.println(i);
            //使用定义的实例变量：
            // 变量类型 变量名 = new demo8()
            demo8 demo8 = new demo8();
            System.out.println(demo8.name); //结果：null
            System.out.println(demo8.age); //结果：0
            System.out.println(salary); //直接输出类变量salary
        }
        //其他方法
        public void add(){ 
            // System.out.println(i); 在Main方法时定义的i，在add方法中不能使用。
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70]  
**2. 常量**

*  常量（Constant）:初始化（Initialize）后不能再改值，不会变动的值。
 *  所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
 *  常量名一般使用**大写字符**。  
    如下代码：

final 常量名 = 值;
    final double PI = 3.14;

public class demo9 { 
        //在类型前的均为修饰符，因此位置互换不影响系统的最终结果。
        static final double  PI = 3.14;
        final static double PI1 = 3.14;
        public static final double PI2 = 3.14;
        public final static double PI3 = 3.14;
        public static void main(String[] args) { 
            System.out.println(PI);
            System.out.println(PI1);
            System.out.println(PI2);
            System.out.println(PI3);
        }
    }

输出结果：  
![在这里插入图片描述][20210203232928473.png]  
**3. 变量的命名规范**

*  所有的变量、方法名、类名：见名知意。
 *  类成员变量：首字母小写和驼峰原则：monthSalary ,即除了第一个字母小写外，后面的单调首字母大写，如 lastName。
 *  局部变量：首字母小写和驼峰原则。
 *  常量：大写字母和下划线。如:MAX\_VALUE。
 *  类变量：首字母大写和驼峰原则。如 Man，GoodMan。
 *  方法名：首字母小写和驼峰原则。如run(),runRun()。
 *  **综上**：  
    1）类成员变量、局部变量、方法名： 首字母小写和驼峰原则。  
    2）常量：大写字母和下划线。  
    3）类变量：首字母大写和驼峰原则。

--------------------

## 3.7基本运算符 ##

1.  **运算符**

*  算术运算符：+，-，\*，/，%（取余，模运算，mod），++，–。
 *  赋值运算符：=。
 *  关系(比较)运算符：>,<,>=,<=,**==**, !=(不等于)，instanceof 。
 *  逻辑运算符：&&，||， ！。（与或非）
 *  位运算符：&，|, ^,~,>>,<<,>>>(了解）。
 *  条件运算符：？：
 *  扩展赋值运算符：+=，-=，\*=，/=。
 *  **算术运算符代码示例**：

package Operator;
    public class Demo01 { 
        public static void main(String[] args) { 
            //二元运算符
            int a =10; //快捷键ctrl+D,复制行。
            int b =20;
            int c =25;
            int d =25;
            System.out.println(a+b);
            System.out.println(a-b);
            System.out.println(a*b);
            System.out.println(a/b);  //计算结果应该为0.5，但由于是Int型，直接取整。
            System.out.println(a/(double)b);  //将任一数值转换为double型，计算结果类型即为double.结果=0.5
    
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 1]

package Operator;
    public class Demo02 { 
        public static void main(String[] args) { 
            long a = 13144124124141L;
            int  b =123;
            short c =10;
            byte d = 8;
    
            System.out.println(a+b+c+d); //结果为long类型， 如果多个不同类型的数值运算，如果有一个数据类型为Long,则整个计算结果的数据类型也为Long.同理，如果里面有一个数据类型为double，则整个计算结果也为double类型。
            System.out.println(b+c+d); //结果为int型,如果多个不同类型的数个运算，如果没有一个数据类型为Long，则整个计算结果的数据类型就为int，无论计算的数据类型有几种。
            System.out.println(c+d); //结果为int型
        }
    }

输出结果：  
![在这里插入图片描述][20210204115456178.png]  
**- 比较运算符示例：**

package Operator;
    public class Demo03 { 
        public static void main(String[] args) { 
            //关系运算符的输出结果：正确/错误，即为布尔类型的true/false
            int a = 10;
            int b = 20;
            int c = 21;
            System.out.println(c%a); //取余运算，模运算。即 21/10=2余1，结果为1
            System.out.println(a>b);
            System.out.println(a<b);
            System.out.println(a==b);
            System.out.println(a!=b);
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 2]

--------------------

## 3.8自增自减运算符，初识Math类 ##

**1. 自增运算示例：**

package Operator;
    public class Demo04 { 
        public static void main(String[] args) { 
            int a = 3;
            int b = a++; //先把a的值赋给b,然后a再进行+1运算得出a=4
            System.out.println(b); //b=3,a=4
            int c = ++a; //先计算a=a+1,a=4+1=5,a=5,再把a的值赋值给c，即c=5
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            //综上，如果++在前面，则先计算自增，如果++在后面，则后计算自增。 -- 同理。
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 3]

*  幂运算示例：

//幂运算，比如2^3=8,在Java中我们会使用一些 工具类 来操作。
            double pow = Math.pow(2,3);
            System.out.println(pow);

--------------------

## 3.9逻辑运算符、位运算符 ##

**1. 逻辑运算**

*  代码示例：

package Operator;
    //逻辑运算符
    public class Demo05 { 
        public static void main(String[] args) { 
            //与(and) 或(or) 非(not)
            boolean a = true;
            boolean b = false;
            System.out.println("a&&b:"+(a&&b)); //与&&：一假则假
            System.out.println("a||b:"+(a||b)); //或||：一真则真
            System.out.println("!(a&&b):"+!(a&&b)); //非！：非真即假，非假即真
    
            //短路运算
            int c = 5;
            boolean d =(c<4) &&(c++<4);  //c<4为假，则不往下进行运算，直接进行短路。
            System.out.println(c);
            System.out.println(d);
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 4]  
**2. 位运算**

package Operator;
    public class Demo06 { 
        public static void main(String[] args) { 
            //位运算
            /* A = 0010 1101 B = 1100 0100 A&B = 0000 0100 //与运算：如果都为1，结果才为1，其余都为0 A|B = 1110 1101 //或运算：如果都为0，结果才为0，其余都为1 A^B = 1110 1001 //异或运算：相同为0，不同为1 ~B = 0011 1011 //取反 */
            //左移与右移
            //如何快速计算 2*8的结果？ 2*2*2*2
            System.out.println(2<<3); // << 左移代表乘， >>右移代表除
           /* 计算机组成原理 0000 0000 0 0000 0001 1 0000 0010 2 0000 0011 3 0000 0100 4 0000 1000 8 0001 0000 16 */
        }
    }

输出结果：  
![在这里插入图片描述][20210204141123869.png]

--------------------

## 3.10三元运算符及小结 ##

**1. 扩展运算符**

*  代码示例：

package Operator;
    public class Demo07 { 
        public static void main(String[] args) { 
            int a =10;
            int b =20;
            a+=b; //a = a+b a=10+20=30
            a-=b; //a = a-b a=30-20=10
            System.out.println(a); //10
            //字符串连接符 +
            System.out.println(a+b);//30
            System.out.println(""+a+b); //如果连接符左侧存在String类型,则结果一并转换为String类型. 结果为1020
            System.out.println(a+b+""); //如果连接符右侧存在String类型,则结果值先计算连接符左侧的数据.
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 5]  
**2. 条件运算符（三元运算符）**

*  运算符的优先级是怎么样的？  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 6]
 *  代码示例：

package Operator;
    public class Demo08 { 
        public static void main(String[] args) { 
            //三元运算符
            int score =60;
            String  type = score<60? "不及格":"及格"; //必须掌握!!
            System.out.println(type);
        }
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 7]

--------------------

## 3.11包机制 ##

**1. 包机制**

*  为了更好的组织 类，Java提供了包机制，用于区别类名的命名空间。通俗的理解为文件夹。
 *  包语句的语法格式为：

package pkg1[.pkg2[.pkg3...]];

*  **一般利用公司域名倒置作为包名。**
 *  为了能够使用某一个包的成员（类），我们需要在Java程序中明确导入该包。使用”import"语句可完成此功能。

import package1[.package2...].(classname| *);

*  " \* "代表引用包下的**所有**类文件。
 *  import 语句必须放到package内部，不能放到package外部。
 *  课外拓展：下载阿里巴巴Java开发者手册。

--------------------

## 3.12JavaDoc生成文档 ##

**1. JavaDoc**

*  JavaDoc命令是用来生成自己的API文档的。
 *  参数信息：  
    1）@author 作者名  
    2）@version 版本号  
    3）@since 指明需要最早使用的JDK版本  
    4）@param 参数名  
    5）@return 返回值情况  
    6）@throws 异常抛出情况
 *  代码示例：

package Operator;
    /** * 这是类的注释文档 * @author lvlanfang * @version 1.0 * @since 1.8 */
    public class Doc { 
        String name;
    
        /** * 这是方法的注释文档 * @param name * @return * @throws Exception */
        public String test (String name) throws Exception{ 
            return name;
        }
    }

*  我们在类文档处右键选择-open in -explorer:  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 8]
 *  在指定的路径前输入 cmd空格进入命令窗口。  
    ![在这里插入图片描述][20210204175523267.png]
 *  在命令窗口中录入以下命令后，回车：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 9]
 *  生成如下文档，打开index.html即可。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 10]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 11]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 12]

--------------------

完。

[Link 1]: https://blog.csdn.net/ydk888888/article/details/81563608
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/25f528fc53f649dfb63a9073c72b922b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/2c3a23dcdfc54e4981e1d5a1deff2e75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/e2799b33f448467b832f0f83f066a71e.png
[2021020312145410.png_pic_center]: /images/20221024/9588ebcb258747f693993e285d75c9c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/11ad6e03accd4d65bd0db401446df07b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221024/9504b6c9cb4849f89de27dbbc058135f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221024/2f0b7024186345a4803cd5a9460db790.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221024/e79c0a175dd6440685ac209f1e24e3ce.png
[20210203130822810.png_pic_center]: /images/20221024/e42b178e794947439fa945b768de1ccd.png
[20210203134414864.png_pic_center]: /images/20221024/c155794de17d43e89e26833c9e6fc0d4.png
[20210203134948578.png_pic_center]: /images/20221024/da8e4a69af284369abd026cd1c4d8cb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221024/88e396284db54372acc662d4a113f928.png
[20210203152711357.png_pic_center]: /images/20221024/d5e2901f5c36431a9686b13e7302c014.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70]: /images/20221024/d2dd5c1685884aa8a89e6e316c959521.png
[20210203232928473.png]: /images/20221024/903200045e90486885fd9adc194b9357.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/5a6206549ed84a81b0fc2b74194a9427.png
[20210204115456178.png]: /images/20221024/d53b6ee52ea0428b8e2ba68242e34139.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 2]: /images/20221024/4001d89aa06442d98910d0b212837bae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 3]: /images/20221024/9043d3815d0940ecb985b14162ab8cbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 4]: /images/20221024/4ad2c3b0da3e455a98f5fe83573861a1.png
[20210204141123869.png]: /images/20221024/2cd1b240531e45a39a71ac0a857228cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 5]: /images/20221024/c721473cee5b46d09cac57696a3660b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 6]: /images/20221024/b455fc3daed349f2a2493fb63e500cd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 7]: /images/20221024/a86c93bff4cc4076a92747fd18978981.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 8]: /images/20221024/454dddfad89f4feda1ead63c739f158c.png
[20210204175523267.png]: /images/20221024/b7aa42b7930d4dd589471bf4fab1250c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 9]: /images/20221024/4b586c969c1d407980493f1e934acb5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 10]: /images/20221024/ac506401cb0f41f5a858541f64f87d26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 11]: /images/20221024/bc2b4738d4c94b03af8f09a57e0450e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODYyODkxNQ_size_16_color_FFFFFF_t_70 12]: /images/20221024/aaa72b5b8d9d4835beaa60b33361f3d2.png