大数据开发基础入门与项目实战（一）Java SE之2.变量和数据类型

本文由我来 wolai - 不仅仅是未来的云端协作平台与个人笔记提供支持，可点击
https://www.wolai.com/signup?invitation=SWEW7UI注册并体验 wolai，或者下载wolai APP或客户端输入邀请码SWEW7UI ，这样你和我都可以获得积分哦。wolai是一个有温度的平台，赶紧来注册体验吧。

前言

本文主要介绍了Java中的变量和数据类型，包括变量（变量的基本概念、变量的声明和使用、标识符的命名法则和手册的介绍和官方库的使用等）和数据类型（数据类型的分类、常用的进制、整数类型、浮点类型、布尔类型、字符类型和类型转换等）。

1.变量

（1）变量的基本概念

当需要在程序中记录单个数据内容 时，则声明一个变量即可，而声明变量的本质就是在内存中申请一个存储单元 ，由于该存储单元中的数据内容可以发生改变 ，因此称为"变量"。

由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在Java语言中使用数据类型 加以描述，为了便于下次访问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。

（2）变量的声明和使用

变量的声明方式为：

数据类型 变量名 = 初始值;

其中=初始值可以省略，但;不可以省略。

新定义VarTest类如下：

/*
  变量的声明和使用
*/

public class VarTest {
  
  public static void main(String args[]) {
    
    // 1.声明int类型类型的变量并初始化
    int age = 18;
    System.out.println("age = " + age);  // +用于将左右两边的内容拼接起来、组成新的字符串
    
  }
}

输出：

age = 18

其中，11行的+是字符连接符，用于将左右两边的内容拼接起来、组成新的字符串。

（3）变量使用的注意事项

1. 使用变量之前需要声明

     Java是强类型语言，变量在使用前必须声明来指明其数据类型，否则会报错错误: 找不到符号。

2. 使用变量之前需要初始化

    否则可能会报错错误: 可能尚未初始化变量name 。

3. 变量不能重复声明

    否则会报错错误: 已在方法 main(String[])中定义了变量 xxx。

例如：

/*
  变量的声明和使用
*/

public class VarTest {
  
  public static void main(String args[]) {
    
    // 1.声明int类型类型的变量并初始化
    int age = 18;
    System.out.println("age = " + age);  // +是字符连接符，用于将左右两边的内容拼接起来、组成新的字符串
    
    // 2.使用变量的注意事项
    // 2.1 使用变量之前需要声明
    // System.out.println("name = " + name);  // 错误: 找不到符号
    // 2.2 使用变量之前需要初始化
    // String name;
    // System.out.println("name = " + name);  // 错误: 可能尚未初始化变量name
    // 2.3 变量不能重复声明
    int age = 20;
    System.out.println("age = " + age);      // 错误: 已在方法 main(String[])中定义了变量 age
  }
}

（4）标识符的命名法则

• 由数字、字母、下划线和$组成，其中数字不能开头

    一般选择字母、数字和下划线命名。

• 不能使用Java中的关键字

    关键字 是Java语言中表示特殊含义的单词，Java中的关键字如下：

• 区分大小写 ，长度没有限制但不宜过长

    标识符的大小写不同时，表示不同的标识符

• 尽量做到见名知意，支持中文但不推荐

• 标识符范围如下：

    - 变量

    - 类

    - 属性

    - 方法

    - 包

（5）变量输入输出案例和优化

提示用户从键盘输入自己的姓名和年龄信息并打印出来。

实现思路：

• 声明两个变量用于记录姓名和年龄信息

• 提示用户输入，并保存到声明的对应变量中

• 打印变量值

根据实现思路设计代码如下：

/*
  变量的输入和输出
*/

// 导入java目录下util目录下的Scanner类
import java.util.Scanner;

public class VarIOTest {
  
  public static void main(String[] args) {
    
    // 1.声明变量
    String name;
    int age;
    
    // 2.提示用户输入
    System.out.println("Please input your name and age: ");
    // 创建一个扫描器来扫描键盘输入的内容，System.in代表键盘输入
    Scanner sc = new Scanner(System.in);
    // 通过扫描器读取字符串数据放入变量name中
    name = sc.next();
    // 通过扫描器读取整型数据放入变量age中
    age = sc.nextInt();
    
    // 3.打印变量的数值
    System.out.println("name = " + name);
    System.out.println("age = " + age);
  }
}

在提示用户输入时，需要从键盘输入中获取数据，此时就需要用到扫描器类Scanner，这是Java中的标准类，通过import java.util.Scanner; 导入即可使用。

在编译运行后，输入和输出示意如下：

Please input your name and age:
Corley 18
name = Corley
age = 18

需要注意，name和age需要按顺序输入，才能正常读入和打印。

上面的代码还可以进行优化：

• 面的实现思路是先声明变量再输入数据并保存到变量，即先申请了存储空间、后边再使用，可能会造成资源的浪费，此时可以将声明变量和输入赋值合并为一步，使得符合“变量随使用随声明 ”的原则；

• 输出时打印了2次，也可以合并为一次，达到尽可能减少重复代码 的目标。

优化现有的代码如下：

/*
  变量的输入和输出
*/

// 导入java目录下util目录下的Scanner类
import java.util.Scanner;

public class VarIOTest {
  
  public static void main(String[] args) {
    
    // 1.声明变量
    // String name;
    // int age;
    
    // 2.提示用户输入
    System.out.println("Please input your name and age: ");
    // 创建一个扫描器来扫描键盘输入的内容，System.in代表键盘输入
    Scanner sc = new Scanner(System.in);
    // 通过扫描器读取字符串数据放入变量name中
    String name = sc.next();
    // 通过扫描器读取整型数据放入变量age中
    int age = sc.nextInt();
    
    // 3.打印变量的数值
    // System.out.println("name = " + name);
    // System.out.println("age = " + age);
    System.out.println("name = " + name + ", age = " + age);
  }
}

输入和输出如下：

Please input your name and age:
Corley 18
name = Corley, age = 18

可以看到，也达到了效果。

（6）手册的介绍和官方库的使用

前面用到的Scanner属于Java官方库，Java中还有很多其他官方库，即API。

JDK中带有大量的API类，是由Java系统带来的工具库，是Java官方程序员的技术积累使用这些类可以大大简化编程、提高开发效率。

具体的API类的功能和使用，可以查看参考手册。

2.数据类型

前面已经用到了int和String两种数据类型，其实还有很多数据类型。

（1）数据类型的分类

Java中的数据类型主要分为两大类：

• 基本数据类型

    - byte

    - short

    - int

    - long

    - float

    - double

    - boolean

    - char

• 引用数据类型

    - 数组

    - 类

    - 接口

    - 枚举

    - 标注

（2）常用的进制

• 常生活中一般采用十进制 ，逢十进一，权重是$10^0$、$10^1$、$10^2$、……

• 计算机底层采用0和1组成的二进制 ，以0b 开头表示，逢二进一，权重是$2^0$、$2^1$、$2^2$、……

    最高位（最左边）用于代表符号位

    - 0表示非负数

    - 1表示负数

• 八进制 和十六进制 是二进制的简写，八进制以0开头表示，十六进制以0x 表示。

（3）进制之间的转换

Ⅰ 正十进制转为二进制

• 除二取余法

    以十进制的45为例，转化为二进制的过程如下：

    然后将右边的余数倒序排列，即得到二进制的数0b101101 ，这其实省略了为0的高位，六十四位机器中可以看到：

    可以看到，64位中的最高位为0、表示正数，从62-6位均为0。

• 拆分法

    将十进制的数拆分成二的权重的和。

    还是以45为例：

    
     45 = 32 + 8 + 4 + 1 = 2^5 + 2^3 + 2^2 + 2^0
    

    有权重的对应位置位1、没有权重则为0，所以二进制的结果为0b101101 。

Ⅱ 正二进制转为十进制

正二进制转换为十进制与正十进制转为二进制的过程正好相反，采用加权法：

使用二进制中的每一位乘对应位的权重再累加求和。

以0b101101 为例如下：

$$1\ast 2^5+0\ast 2^4+1\ast 2^3+1\ast 2^2+1\ast 2^0=32+8+4+1=45$$

Ⅲ 负十进制转为二进制

先将十进制的绝对值转为二进制，然后进行按位取反再加1。

以十进制-45为例：

1. 将十进制的45转换为二进制

    45转为二进制，为0b00101101

2. 按位取反

    取反得到11010010

3. 加1

    相加，$11010010+1=11010011$，所以结果为0b11010011 。

得到结果后可以进行校验，将得到的值与正的二进制相加，看看相加是否为0，如果相加最高位进1、则省去。

Ⅳ 负二进制转为十进制

过程与负十进制转为二进制过程相反，

以0b11010011 为例

• 先减1

    得到0b11010010

• 按位取反

    得到0b0011101

• 转为十进制

    得到45。

（4）单个字节表示的整数范围

计算机中，一个字节占8位，其中最高位（第一位）表示符号，所以数值占7位：

• 非负数表示的整数范围为0000 0000 - 0111 1111，即0 - 127

• 负数表示的整数范围为1000 0000 - 11111111，即-128 - -1

所以单个字节所能表示的整数范围为-128 - 127，即$-2^7-2^7-1$。

（5）整数类型

Java中描述整数数据的类型有4个：

• byte

    在内存空间中占1个字节，即8位，范围为$-2^7-2^7-1$，即-128 - 127。

• short

    在内存空间中占2个字节，即16位，范围为$-2^{15}-2^{15}-1$，即-32768 - 32767。

• int

    在内存空间中占4个字节，即32位，范围为$-2^{31}-2^{31}-1$。

• long

    在内存空间中占8个字节，即64位，范围为$-2^{63}-2^{63}-1$。

推荐使用int类型，因为int相比于byte、short范围更大 、不易超过，相比于long省内存 。

（6）整数类型的编程使用

先进行byte的使用测试：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化
    byte b1 = 25;
    // 2.打印
    System.out.println("b1 = " + b1);
  }
}

输出：

b1 = 25

再进行超范围的测试，即使用超过byte范围的值进行计算，如下：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化，超范围测试
    byte b1 = 250;
    // 2.打印
    System.out.println("b1 = " + b1);
  }
}

输出：

IntTest.java:9: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                byte b1 = 250;
                          ^
1 个错误
错误: 编译失败

可以看到，因为超过了byte的最大范围127，所以报错。

上面代码中的250这样直接写出的数据称为直接量 或常量或字面值，默认为int类型，范围比byte大，此时可以声明short或者更大范围的类型。

short类型测试如下：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化
    byte b1 = 25;
    // 2.打印
    System.out.println("b1 = " + b1);
    // 3.声明short类型并初始化
    short s1 = 250;
    // 4.打印
    System.out.println("s1 = " + s1);
  }
}

输出：

b1 = 25 
s1 = 250
 

如果超过short范围，则会报错错误: 不兼容的类型: 从int转换到short可能会有损失。

再测试int类型，如下：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化
    byte b1 = 25;
    // 2.打印
    System.out.println("b1 = " + b1);
    // 3.声明short类型并初始化
    short s1 = 250;
    // 4.打印
    System.out.println("s1 = " + s1);
    // 3.声明int类型并初始化
    int i1 = 250250;
    // 4.打印
    System.out.println("i1 = " + i1);
  }
}

再测试超出int范围，如下：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化
    byte b1 = 25;
    // 2.打印
    System.out.println("b1 = " + b1);
    // 3.声明short类型并初始化
    short s1 = 250;
    // 4.打印
    System.out.println("s1 = " + s1);
    // 3.声明int类型并初始化，超范围测试
    int i1 = 250250250250;
    // 4.打印
    System.out.println("i1 = " + i1);
  }
}

输出：

IntTest.java:17: 错误: 整数太大
                int i1 = 250250250250;
                         ^
1 个错误
错误: 编译失败

因为默认为int类型，此时这个数据已经出错，无法显示。

此时需要进行类型转换，再数值后面加上字母L 或l 即可，最好使用大写字母，便于与数字1 区分开。

即上面可改为250250250250L ，此时就会报错错误: 不兼容的类型: 从long转换到int可能会有损失 。

long类型测试如下：

/*
  整数类型的使用
*/

public class IntTest {
  
  public static void main(String[] args) {
    // 1.声明byte类型并初始化
    byte b1 = 25;
    // 2.打印
    System.out.println("b1 = " + b1);
    // 3.声明short类型并初始化
    short s1 = 250;
    // 4.打印
    System.out.println("s1 = " + s1);
    // 5.声明int类型并初始化
    int i1 = 250250;
    // 6.打印
    System.out.println("i1 = " + i1);
    // 7.声明long类型并初始化
    long l1 = 250250250250L;
    // 8.打印
    System.out.println("l1 = " + l1);
  }
}

输出：

b1 = 25
s1 = 250
i1 = 250250
l1 = 250250250250
 

（7）整型类型笔试考点

1. 标识符命名规则中，数字为什么不能开头？

       如果标识符中可以以数字开头，则可能会有123 的变量名，则编译器分不清楚这是一个变量，还是一个直接量，所以Java官方退出这个规定，Java也称为“安全的语言”。

2. 下面的代码是否有错误？若有请指出并说明原因。

   int i1 = 25;
   byte b2 = i2;
   System.print.println("b2 = " + b2);
   

   编译运行时，会报错不兼容的类型: 从int转换到byte可能会有损失 ，因为int型转化为byte型可能有精度的损失，虽然这里的值很小，但是变量的值可能随时改变，如果数值变得很大时，就可能会超出byte类型的范围。

（8）浮点类型

浮点类型是Java中用于描述小数数据的类型，包括

• float

    内存空间中占4个字节，叫单精度浮点数，可以表示7位有效数字，范围是$-3.4\ast 10^{38}-3.4\ast 10^{38}$。

• double

    内存空间中占8个字节，叫双精度浮点数，可以表示15位有效数字，范围是$-1.798\ast 10^{308}-1.798\ast 10^{308}$。

推荐使用double 类型，精度（有效位数）更高，同时多占的字节数也可以忽略不计。

（9）浮点类型的编程使用

float类型测试如下：

/*
  浮点类型的使用
*/

public class DoubleTest {
  
  public static void main(String[] args) {
    
    // 1.声明float类型变量并初始化
    float f1 = 3.14159f;
    float f2 = 3.1415926535f;
    // 2.打印变量的值
    System.out.println("f1 = " + f1);
    System.out.println("f2 = " + f2);
  }
}

输出：

f1 = 3.14159
f2 = 3.1415927

如果代码中不加f ，即float f1 = 3.14159f; ，会报错不兼容的类型: 从double转换到float可能会有损失 ，这是因为：

小数数据叫直接量，默认是double类型，将double类型的值赋值给float类型时会有所占字节数和有效位数的损失。

还可以关注到，f2打印出来和原来赋的值不一样，这是因为float型的有效位数为7、最多只能保留7位小数。

再测试double型，如下：

/*
  浮点类型的使用
*/

public class DoubleTest {
  
  public static void main(String[] args) {
    
    // 1.声明float类型变量并初始化
    float f1 = 3.14159f;
    float f2 = 3.1415926535f;
    // 2.打印变量的值
    System.out.println("f1 = " + f1);
    System.out.println("f2 = " + f2);
    // 3.声明double类型变量并初始化
    double d1 = 3.14159;
    double d2 = 3.1415926535;
    // 4.打印变量的值
    System.out.println("d1 = " + d1);
    System.out.println("d2 = " + d2);
  }
}

输出：

f1 = 3.14159
f2 = 3.1415927
d1 = 3.14159
d2 = 3.1415926535

可以看到，因为数值在double的有效位数范围内，所以打印出了原数值。

double计算时可能会有误差，若希望实现精确计算则可以使用java.math.BigDecimal。

（10）布尔类型的概念和使用

布尔类型是Java中用于描述真假信息的类型，数值只有true 和false 。

布尔类型在内存空间中所占大小没有明确规定，可以认为是1个字节 。

使用如下：

/*
  布尔类型的使用
*/

public class BooleanTest{
  
  public static void main(String[] args) {
    
    // 1.声明boolean类型变量并初始化
    boolean b1 = true;
    System.out.println("b1 = " + b1);
    b1 = false;
    System.out.println("b1 = " + b1);
  }
}

输出：

b1 = true
b1 = false

其中第12行的= 是赋值运算符，即将= 右边的值赋值给左边的变量、覆盖变量原来的值。

不能将true 和false 以外的其他值赋值给boolean类型的变量，否则会报错，例如上面第12行改为b1 = 25; 时会报错不兼容的类型: int无法转换为boolean。

（11）字符类型的概念和使用

char类型（字符类型）是Java语言中用于描述单个字符的数据类型，如：‘a’、'中’等。

其中char类型在内存空间中占2个字节并且没有符号位 ，表示的范围是0 ~ 65535。

由于现实生活中很少有数据能够被单个字符描述，因此以后的开发中更多的是使用由多个字符串起来组成的字符串，使用String类型 加以描述，如：“hello”、“Corley”等。

计算机的底层只识别0和1组成的二进制序列，char类型的图案数据不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就需要给该数据指定一个编号，然后将编号存储起来即可，该编号即为ASCII。

使用如下：

/*
  字符类型的使用
*/

public class CharTest {
  
  public static void main(String[] args) {
    
    // 1.声明char类型变量并初始化
    char c1 = 'a';
    // 2.打印变量值
    System.out.println("c1 = " + c1);
    System.out.println("c1字符的对应编号为：" + (int)c1);
    // 3.声明char类型变量并初始化
    char c2 = 98;
    // 4.打印变量值
    System.out.println("c2 = " + c2);
    System.out.println("c2字符的对应编号为：" + (int)c2);
  }
}

打印：

c1 = a
c1字符的对应编号为：97
c2 = b
c2字符的对应编号为：98

其中，(int)c1 是将char类型的c1强制转化为int类型；

因为计算机底层存储char类型时存储的都是编号，因此也可以直接将整型的值赋值给char型变量。

（12）Unicode字符集的概念和使用

从上面可以知道，a的ASCII编号是97、b是98，常见的ASCII包括：

• ‘0’ - 48

• ‘A’ - 65

• ‘a’ - 97

• 空格 - 32

• 换行符 - 10

ASCII表具体如下：

其中，ASCII表的范围是0-127，包含了字母、数字和一些符号，并不包含中文等其他符号，这就出现了Unicode字符集，这个字符集包含了各国语言的字符集，是世界通用的定长字符集，所有的字符都是16位。

Java中使用Unicode字符集如下：

/*
  字符类型的使用
*/

public class CharTest {
  
  public static void main(String[] args) {
    
    // 1.声明char类型变量并初始化
    char c1 = 'a';
    // 2.打印变量值
    System.out.println("c1 = " + c1);
    System.out.println("c1字符的对应编号为：" + (int)c1);
    // 3.声明char类型变量并初始化
    char c2 = 98;
    // 4.打印变量值
    System.out.println("c2 = " + c2);
    System.out.println("c2字符的对应编号为：" + (int)c2);
    // 5.使用Unicode字符集展示中文
    char c3 = '\u5965';
    char c4 = '\u8fd0';
    System.out.println("Unicode奥运：" + c3 + c4);
  }
}

输出：

c1 = a
c1字符的对应编号为：97
c2 = b
c2字符的对应编号为：98
Unicode奥运：奥运

可以看到，给char型变量赋值Unicode编码，输出了中文字符。

（13）转义字符的概念和使用

双引号本身有2层含义：

• 字符串的开头和结尾

• 双引号符号自身

默认情况下双引号就是作为字符串的开头和结尾，要想使用双引号符号自身，则需要转义字符\ 对双引号进行转义，这就组成转义字符\" ，主要转义字符如下：

字符	含义
"	"
’	’
\	\
\t	制表符
\n	换行符

简单使用如下：

/*
  字符类型的使用
*/

public class CharTest {
  
  public static void main(String[] args) {
    
    // 1.声明char类型变量并初始化
    char c1 = 'a';
    // 2.打印变量值
    System.out.println("c1 = " + c1);
    System.out.println("c1字符的对应编号为：" + (int)c1);
    // 3.声明char类型变量并初始化
    char c2 = 98;
    // 4.打印变量值
    System.out.println("c2 = " + c2);
    System.out.println("c2字符的对应编号为：" + (int)c2);
    // 5.使用Unicode字符集展示中文
    char c3 = '\u5965';
    char c4 = '\u8fd0';
    System.out.println("Unicode奥运：" + c3 + c4);
    // 6.特殊字符的使用
    System.out.println();
    System.out.println("有人曾说\"一切反动派都是纸老虎\"");    // \"代表"
    System.out.println("有人曾说\'一切反动派都是纸老虎\'");    // \'代表'
    System.out.println("有人曾说\\一切反动派都是纸老虎\\");    /* \\代表\ */
  }
}

输出：

c1 = a
c1字符的对应编号为：97
c2 = b
c2字符的对应编号为：98
Unicode奥运：奥运

有人曾说"一切反动派都是纸老虎"
有人曾说'一切反动派都是纸老虎'
有人曾说\一切反动派都是纸老虎\

（14）类型转换的概念和使用

类型转换：

• 自动类型转换

    一般指从小类型到大类型的转换。

• 强制类型转换

    一般指从大类型到小类型的转换，格式为target_var = (type)source_var; 。

自动类型转换使用如下：

/*
  基本数据类型之间的转换
*/

public class TransformTest {
  
  public static void main(String[] args) {
    
    // 1.声明2个变量并初始化
    byte b1 = 10;
    short s1 = 20;
    // 2.打印变量
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
    // 3.自动类型转换
    // 将变量b1的值赋值给s1
    s1 = b1;
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
  }
}

输出：

b1 = 10
s1 = 20
b1 = 10
s1 = 10

其中，第17行将变量b1的值赋值给s1，并覆盖s1中原来的数值，相当于从byte类型到short类型的转换，小到大、属于自动类型转换。

强制类型转换使用如下：

/*
  基本数据类型之间的转换
*/

public class TransformTest {
  
  public static void main(String[] args) {
    
    // 1.声明2个变量并初始化
    byte b1 = 10;
    short s1 = 20;
    // 2.打印变量
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
    // 3.自动类型转换
    // 将变量b1的值赋值给s1
    s1 = b1;
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
    // 将变量s1的数值赋值给变量b1
    b1 = (byte)s1;
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
  }
}

输出：

b1 = 10
s1 = 20
b1 = 10
s1 = 10
b1 = 10
s1 = 10

其中，第21行将变量s1的数值赋值给变量b1，并覆盖b1原来的值，相当于从short类型到byte类型的转换，大到小、属于强制类型转换。

再来测试：

/*
  基本数据类型之间的转换
*/

public class TransformTest {
  
  public static void main(String[] args) {
    
    // 1.声明2个变量并初始化
    byte b1 = 10;
    short s1 = 20;
    // 2.打印变量
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
    // 3.自动类型转换
    // 将变量b1的值赋值给s1
    s1 = b1;
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
    // 将变量s1的数值赋值给变量b1
    s1 = 128;
    b1 = (byte)s1;
    System.out.println("b1 = " + b1);
    System.out.println("s1 = " + s1);
  }
}

输出：

b1 = 10  
s1 = 20  
b1 = 10  
s1 = 10  
b1 = -128
s1 = 128 

可以看到，此时出现了损失，因为short类型转化为byte类型时，只取低8位，即0b1000 0000 对应的十进制为-128。

总结

变量和数据类型是Java的基础，是后面一切知识体系的根基，万丈高楼平地起，因此需要熟练掌握。

同时，本文只是知识文档的部分内容，如果要获取更完整的文档，可以私信交流。