Java 数据类型、运算符

迷南。 2024-03-03 03:43 92阅读 0赞

### 一、数据类型 ###

#### 1、数据类型介绍 ####

**基本数据类型**

![432c332ae7d0494fa0b6a8d462196db4.png][]

**补充1： 计算机存储单位**

*  **字节（Byte）：**是计算机用于计量存储容量的基本单位，一个字节等于8 bit。
 *  **位（bit）：**是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。
 *  **转换关系：**
    
     *  8 bit = 1 Byte
     *  1024 Byte = 1 KB
     *  1024 KB = 1 MB
     *  1024 MB = 1 GB
     *  1024 GB = 1 TB

**补充2：整型int 和 long**

*  定义long类型的变量，赋值时需要以" l "或" L "作为后缀。
 *  Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
 *  Java的整型**常量默认为 int 型**。

**补充3：浮点型float 和 double**

*  浮点型常量有两种表示形式：
    
     *  十进制数形式。如：5.12 512.0f .512 (必须有小数点）
     *  科学计数法形式。如：5.12e2 512E2 100E-2
 *  float：**单精度**，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
 *  double：**双精度**，精度是float的两倍。通常采用此类型。
 *  定义float类型的变量，赋值时需要以" f "或" F "作为后缀。
 *  Java 的浮点型**常量默认为double型**。

**补充4：字符类型 char**

*  char 型数据用来表示通常意义上“字符”（占2字节）
 *  Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
 *  字符型变量的三种表现形式：
    
     *  **形式1：**使用单引号(' ')括起来的单个字符。
        
        例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
     *  **形式2：**直接使用 Unicode值来表示字符型常量：‘\\uXXXX’。其中，XXXX代表一个十六进制整数。
        
        例如：\\u0023 表示 '\#'。
     *  **形式3：**Java中还允许使用转义字符‘\\’来将其后的字符转变为特殊字符型常量。
        
        例如：char c3 = '\\n'; // '\\n'表示换行符

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>说明</th> 
   <th>Unicode表示方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\n</td> 
   <td>换行符</td> 
   <td>\u000a</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>制表符</td> 
   <td>\u0009</td> 
  </tr> 
  <tr> 
   <td>\"</td> 
   <td>双引号</td> 
   <td>\u0022</td> 
  </tr> 
  <tr> 
   <td>\'</td> 
   <td>单引号</td> 
   <td>\u0027</td> 
  </tr> 
  <tr> 
   <td>\\</td> 
   <td>反斜线</td> 
   <td>\u005c</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格符</td> 
   <td>\u0008</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车符</td> 
   <td>\u000d</td> 
  </tr> 
 </tbody> 
</table>

char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

**补充5：布尔类型 boolean**

*  boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
    
     *  if条件控制语句；
     *  while循环控制语句；
     *  for循环控制语句；
     *  do-while循环控制语句；
 *  **boolean类型数据只有两个值：true、false，无其它。**
    
     *  不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

#### **2.、引用数据类型** ####

**字符串类型：String**

*  String不是基本数据类型，属于引用数据类型
 *  使用一对`""`来表示一个字符串，内部可以包含0个、1个或多个字符。
 *  声明方式与基本数据类型类似。例如：String str = “中国”;

### 二、类型转换 ###

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

转换的方式有两种：**自动类型转换**和**强制类型转换**。

#### 1、自动类型转换 - 隐式转换 ####

介绍：将取值范围小的数据或变量，给取值范围大的变量赋值，可以直接赋值。

简单记：小的给大的赋值，可以直接给。

基本数据类型的转换规则如图所示：

![0e03ddc58e1648faa2fbbb184a604bd3.png][]

**解释：**

（1）byte、short、char 三种数据在运算的时候，都会提升为int，然后再进行运算。

（2）虽然float占用4个字节，但是【取值范围】要比8个字节的long更大。

\- 小数的二进制存储形式，更加节省内存。

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。

> int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了  
> double d = 10;//int自动升级为double  
> long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
> 
> //byte bigB = 130;//错误，右边的整数常量值超过byte范围  
> long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

> int i = 1;  
> byte b = 1;  
> double d = 1.0;
> 
> double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

> byte b1 = 1;  
> byte b2 = 2;  
> byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int
> 
> char c1 = '0';  
> char c2 = 'A';  
> int i = c1 + c2;//至少需要使用int类型来接收  
> System.out.println(c1 + c2);//113

#### 2、强制类型转换 - 显示转换 ####

介绍：将取值范围大的数据或变量，给取值范围小的变量赋值，不允许直接赋值，需要加入强转。

格式：目标数据类型 变量名 = (目标数据类型) 被强转的数据；

注意：强制转换【有可能】会出现精度损失

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

> int i = (int)3.14;//损失精度
> 
> double d = 1.2;  
> int num = (int)d;//损失精度
> 
> int i = 200;  
> byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

> int i = 1;  
> int j = 2;  
> double bigger = (double)(i/j);

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

> long l1 = 123L;  
> long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型
> 
> //long l3 = 123123123123; //报错，因为123123123123超出了int的范围。  
> long l4 = 123123123123L;
> 
>   
> //float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型  
> float f2 = 12.3F;  
> float f3 = (float)12.3;

### 三、计算机底层如何存储数据 ###

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

#### 1、进制的分类 ####

*  **二进制**：二进制数据是用0和1两个数码来表示。
    
    进位规则是“逢二进一”，借位规则是“借一当二”。
 *  **八进制**：采用0，1，2，3，4，5，6，7八个数字，逢八进1
 *  **十进制**：由0、1、2、3、4、5、6、7、8、9进行表示
    
    逢十进一，借一当十。
 *  **十六进制**：用数字0到9和字母A到F（或a~f）表示，其中: a~f 表示10~15，这些称作十六进制。
    
    【0】【1】【2】【3】【4】【5】【6】【7】【8】【9】【a】【b】【c】【d】【e】【f】

public class ScaleDemo {
       
        public static void main(String[] args) {
    
            System.out.println(110);
            System.out.println(0b110);
            System.out.println(0110);
            System.out.println(0x110);
    
    
        }
    }

#### 2、进制的换算举例 ####

#### 3、二进制到十进制转换 ####

![ca46e91e440f4e3e95a1dd5baea4d2f1.png][]

**8421快速转换法**

二进制中, 每一位的1都是代表一个固定数值，把每一位的1代表的十进制数加起来得到的结果就是它所代表的十进制数。

![7117de1b59a14732b4cefe722f76ec75.png][]

#### 4、原码反码补码 ####

**原码：**数据的二进制体现形式，一个字节由 8 个二进制位组成。

高位：二进制数据中，最左侧的数据，通过高位代表符号位

0 代表正数

1 代表负数

其余位，表示数值大小

弊端：遇到负数运算，可能会出现错误。

**反码：**正数的反码与其原码相同，负数的反码是对其原码逐位取反，但符号位除外。

**补码：** 正数的补码与其原码相同，负数的补码是在其反码的末位加1。

![0f922421ed9c44e68447b8e335a3f207.png][] ![c201b0be17d9490180e4335182159384.png][]

### 四、运算符 ###

运算符：对字面量或者变量进行操作的**符号。**

表达式：用**运算符**把字面量或者变量连接起来**符合****java****语法的式子**就可以称为表达式。

不同运算符连接的表达式体现的是不同类型的表达式。

> 举例说明：
> 
> int a = 10;
> 
> int b = 20;
> 
> int c = a + b;
> 
> **+****：是运算符**，并且是算术运算符
> 
> **a + b****：是表达式**，由于+是算术运算符，所以这个表达式叫算术表达式

#### 1、算数运算符 ####

![4db981d62a9b4c5b8a49a659b6f9efc4.png][]

举例1：加减乘除取模

public class ArithmeticTest1 {
    	public static void main(String[] args) {
    		int a = 3;
    		int b = 4;
    		
    		System.out.println(a + b);// 7
    		System.out.println(a - b);// -1
    		System.out.println(a * b);// 12
    		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
    		System.out.println(a % b);// 3
            
            //结果与被模数符号相同
            System.out.println(5%2);//1
    		System.out.println(5%-2);//1
    		System.out.println(-5%2);//-1
    		System.out.println(-5%-2);//-1		
    		//商*除数 + 余数 = 被除数
    		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
    		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
    	}
    }

**注意事项：**

/ 和 % 的区别：两个数据做除法，/ 取结果的商，% 取结果的 余数。

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

举例2：" + "号的两种用法

public class ArithmeticTest2 {
    	public static void main(String[] args) {
    		// 字符串类型的变量基本使用
    		// 数据类型 变量名称 = 数据值;
    		String str1 = "Hello";
    		System.out.println(str1); // Hello
    		
    		System.out.println("Hello" + "World"); // HelloWorld
    		
    		String str2 = "Java";
    		// String + int --> String
    		System.out.println(str2 + 520); // Java520
    		// String + int + int
    		// String		+ int
    		// String
    		System.out.println(str2 + 5 + 20); // Java520
    	}
    }

举例3：自增自减运算

理解：++ 运算，表示 自增1。同理，-- 运算，表示 自减1 ，用法与 ++ 一致。

1、单独使用

*  变量在单独运算的时候，变量前++和变量后++，是没有区别的。
 *  变量前++：例如 ++a。
 *  变量后++：例如 a++ 。

public class ArithmeticTest3 {
    	public static void main(String[] args) {
    		// 定义一个int类型的变量a
    		int a = 3;
    		//++a;
    		a++;
            // 无论是变量前++还是变量后++，结果都是4
    		System.out.println(a);
    	}
    }

2、复合使用

*  和其他变量放在一起使用或者和输出语句放在一起使用，前++ 和 后++ 就产生了不同。

*  变量 前++ ：变量先自增1，然后再运算。
 *  变量 后++ ：变量先运算，然后再自增1。

public class ArithmeticTest4 {
    	public static void main(String[] args) {
    		// 其他变量放在一起使用
    		int x = 3;
    		//int y = ++x; // y的值是4，x的值是4，
    		int y = x++; // y的值是3，x的值是4
    		
    		System.out.println(x);
    		System.out.println(y);
    		System.out.println("==========");
            
    		// 和输出语句一起
    		int z = 5;
    		//System.out.println(++z);// 输出结果是6，z的值也是6
    		System.out.println(z++);// 输出结果是5，z的值是6
    		System.out.println(z);
            
    	} 
    }

案例：

// 1. 导包
    import java.util.Scanner;
    
    public class OperatorTest1 {
        /*
            需求: 键盘录入一个三位数, 将数值拆分出个位, 十位, 百位, 随后打印在控制台
    
                    数值拆分的公式 :
    
                        个位: 数值 % 10
                        十位: 数值 / 10 % 10
                        百位: 数值 / 10 / 10 % 10
                        千位: 数值 / 10 / 10 / 10 % 10
                        ...
    
                     对于数值的最高位, 简化处理
    
                        123 : 百位            123 / 100  ---> 1
                        1234 : 千位           1234 / 1000 ---> 1
                        12345 : 万位          12345 / 10000 ---> 1
         */
        public static void main(String[] args) {
    
            // 2. 创建Scanner对象
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个三位数:");
            // 3. 从键盘录入一个整数
            int num = sc.nextInt();
            // 4. 数值拆分
            int ge = num % 10;
            int shi = num / 10 % 10;
            int bai = num / 100;
            // 5. 将拆分后的数据, 打印在控制台
            System.out.println("整数" + num + "的个位为:" + ge);
            System.out.println("整数" + num + "的十位为:" + shi);
            System.out.println("整数" + num + "的百位为:" + bai);
    
        }
    }

#### 2、赋值运算符 ####

![58e5e422a3844921a87ee8c2406c0b14.png][]

注意事项：

扩展的赋值运算符隐含了强制类型转换。

举例：

public class SetValueTest1 {
    	public static void main(String[] args) {
    		int i1 = 10;
    		long l1 = i1; //自动类型转换
    
    		byte bb1 = (byte)i1; //强制类型转换
    
    		int i2 = i1;
    
    		//连续赋值的测试
    		//以前的写法
    		int a1 = 10;
    		int b1 = 10;
    		
    		//连续赋值的写法
    		int a2,b2;
    		a2 = b2 = 10;
    		
    		int a3 = 10,b3 = 20;
    
    		//举例说明+=  -=  *=  /=   %=  
    		int m1 = 10;
    		m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
    		System.out.println(m1);//15
    		
    		//练习1：开发中，如何实现一个变量+2的操作呢？
    		// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
    		//写法1：推荐
    		short s1 = 10;
    		s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
    		System.out.println(s1);//12
    		//写法2：
    		short s2 = 10;
    		//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
    		s2 = (short)(s2 + 2);
    		System.out.println(s2);
    
    
    		//练习2：开发中，如何实现一个变量+1的操作呢？
    		//写法1：推荐
    		int num1 = 10;
    		num1++;
    		System.out.println(num1);
    
    		//写法2：
    		int num2 = 10;
    		num2 += 1;
    		System.out.println(num2);
    
    		//写法3：
    		int num3 = 10;
    		num3 = num3 + 1;
    		System.out.println(num3);
    
    	}
    }

#### 3、关系运算符 ####

![c54cd76e0d9345b88cd237a396246900.png][]

注意事项：

关系运算符的**结果**都是 **boolean** 类型，要么是true，要么是false。

千万不要把 == 误写成 = 。

举例：

public class CompareTest {
    	public static void main(String[] args) {
    		int i1 = 10;
    		int i2 = 20;
    		
    		System.out.println(i1 == i2);//false
    		System.out.println(i1 != i2);//true
    		System.out.println(i1 >= i2);//false
    
    
    		int m = 10;
    		int n = 20;
    		System.out.println(m == n);//false
    		System.out.println(m = n);//20
    
    		boolean b1 = false;
    		boolean b2 = true;
    		System.out.println(b1 == b2);//false
    		System.out.println(b1 = b2);//true
    	}
    }

思考：

> boolean b1 = false;  
> //区分好==和=的区别。  
> if(b1 == true) //if(b1 = true)  
> System.out.println("结果为真");  
> else  
> System.out.println("结果为假");

#### 4、逻辑运算符 ####

![3b9fd665b4594e2d89064d6589434d3c.png][]

![d73d5a6294cf42329c274176b0f8de0b.png][]

小结：

逻辑与 **&**，无论左边 true false，右边都要执行。

短路与 **&&**，如果左边为 true，右边执行；如果**左边为** **false****，右边不执行**。

逻辑或 **|**，无论左边 true false，右边都要执行。

短路或 **||**，如果左边为 false，右边执行；如果**左边为** **true****，右边不执行。**

最常用的逻辑运算符：**&&** **|| !**

举例：

public class OperatorDemo1 {
        /*
            逻辑运算符 :
    
                1. 用于连接boolean类型的表达式, 或者是值
                2. 整合多个条件, 为一段整体的逻辑
    
            分类:
    
                &(与) : 并且, 遇false, 则false
    
                        场景: 范围性的判断查找
                        举例: 键盘录入一个学生成绩, 判断该成绩是否是90~100之间
                        伪代码: 不能运行, 仅供理解
    
                        int score = 95;
    
                        如果(score >= 90 & score <= 100){
                        }
    
                |(或) : 或者, 遇true, 则true
    
                        场景: 多个条件任选其一
                        举例: 键盘录入一个学生学号, 学号 3 5 12
    
                        int id = 3;
    
                        如果(id == 3 | id == 5 | id == 12){
                        }
    
                !(非) : 取反
    
                        场景: 对一段逻辑整体做取反操作
                        举例: 键盘录入一个学生学号, 学号除了 3 5 12 都要
    
                        如果(  ! (id == 3 | id == 5 | id == 12)  ){
                        }
    
                ^(异或) : 相同为false, 不同为true
         */
        public static void main(String[] args) {
    
            System.out.println(true & true);
            System.out.println(true & false);
            System.out.println(false & true);
            System.out.println(false & false);
    
            System.out.println("------------------------------");
    
            System.out.println(true | true);
            System.out.println(true | false);
            System.out.println(false | true);
            System.out.println(false | false);
    
            System.out.println("------------------------------");
    
            System.out.println(!true);
            System.out.println(!false);
    
            System.out.println("------------------------------");
    
            System.out.println(true ^ true);
            System.out.println(true ^ false);
            System.out.println(false ^ true);
            System.out.println(false ^ false);
    
        }
    }

#### 5、三元运算符 ####

**格式**：判断条件 **？** 值1 **:** 值2；

**执行流程**：

首先计算**判断条件的值；**

如果值为**true**，**值****1**就是运算结果；

如果值为**false**，**值****2**就是运算结果。

**总结**：根据判断条件，从两份数据中二者选其一。

举例：

public class OperatorDemo2 {
        /*
            三元运算符 (三目运算符)
    
                格式:
                        判断条件 ? 值1 : 值2;
    
                执行流程
                        1. 执行判断条件, 看其返回结果是true, false
                        2. true : 值1就是最终结果
                        3. false : 值2就是最终结果
    
                需求: 求两个整数的最大值
         */
        public static void main(String[] args) {
            int num1 = 10;
            int num2 = 20;
    
            // hold?fish:palm;
    
            int max = num1 > num2 ? num1 : num2;
    
            System.out.println(max);
        }
    }

案例：

// 1. 导包
    import java.util.Scanner;
    
    public class OperatorTest1 {
        /*
            需求: 键盘录入三个整数, 求出最大值并打印在控制台
         */
        public static void main(String[] args) {
    
            // 2. 创建Scanner对象
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入三个整数:");
            // 3. 从键盘录入三个整数
            int num1 = sc.nextInt();
            int num2 = sc.nextInt();
            int num3 = sc.nextInt();
    
            // 4. 计算出前两个整数的最大值 - tempMax
            int tempMax = num1 > num2 ? num1 : num2;
    
            // 5. 计算出三个整数的最大值 - tempMax 和 第三个整数进行计算
            int max = tempMax > num3 ? tempMax : num3;
    
            // 6. 将最大值打印在控制台
            System.out.println("最大值为:" + max);
    
        }
    }

#### 6、运算符优先级 ####

![c4ee141d831c42c5ae0a505ffeadbce8.png][]

### 五、Scanner键盘录入 ###

**三步骤：**

1.先导入Java.util.Scanner包

> import java.util.Scanner;

2.创建[Scanner类][Scanner]的对象

> //创建对象sc
> 
> Scanner sc = new Scanner(System.in);

3.创建一个变量来接收数据

> int age = sc.nextInt(); 从键盘录入整数, 并使用int类型变量接收  
> double height = sc.nextDouble(); 从键盘录入小数, 并使用double类型变量接收  
> boolean flag = sc.nextBoolean(); 从键盘录入布尔, 并使用boolean类型变量接收  
> String name = sc.next(); 从键盘录入字符串, 并使用String类型变量接收

// 1. 导包
    import java.util.Scanner;
    
    public class ScannerTest {
        public static void main(String[] args) {
            // 2. 创建scanner对象
            Scanner sc = new Scanner(System.in);
    
            // 3. 键盘录入姓名
            System.out.println("请输入您的姓名:");
            String name = sc.next();
    
            // 4. 键盘录入年龄
            System.out.println("请输入您的年龄:");
            int age = sc.nextInt();
    
            // 5. 键盘录入性别
            System.out.println("请输入您的性别:");
            String gender = sc.next();
    
            // 6. 键盘录入身高
            System.out.println("请输入您的身高:");
            double height = sc.nextDouble();
    
            // 7. 键盘录入婚姻状况
            System.out.println("请输入您的婚姻状况:");
            boolean flag = sc.nextBoolean();
    
            System.out.println("注册成功!");
    
            System.out.println(name);
            System.out.println(age);
            System.out.println(gender);
            System.out.println(height);
            System.out.println(flag);
        }
    }

[432c332ae7d0494fa0b6a8d462196db4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/2e9aa3d44be54c07b5032072112dd0e6.png
[0e03ddc58e1648faa2fbbb184a604bd3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/ecf97de059c141a9867127ab1c892bf1.png
[ca46e91e440f4e3e95a1dd5baea4d2f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/c0496124c2e544e6af1fe506e5929d22.png
[7117de1b59a14732b4cefe722f76ec75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/0401fbcc6bdf4502b75b9aadb84385a7.png
[0f922421ed9c44e68447b8e335a3f207.png]: https://img-blog.csdnimg.cn/0f922421ed9c44e68447b8e335a3f207.png
[c201b0be17d9490180e4335182159384.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/fbce17145cbb44e9b636634a16817d82.png
[4db981d62a9b4c5b8a49a659b6f9efc4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/9b7412629160413792154ea20324fefb.png
[58e5e422a3844921a87ee8c2406c0b14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/bb596ba588dc47b0b4c294225d697b0e.png
[c54cd76e0d9345b88cd237a396246900.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/479bdad269cb4374ad2f301e64c2d0df.png
[3b9fd665b4594e2d89064d6589434d3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/17d2c292b8414398a2b0ffd031d31196.png
[d73d5a6294cf42329c274176b0f8de0b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/f444ba125efc4bcc81984ea4dd461445.png
[c4ee141d831c42c5ae0a505ffeadbce8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/a59a489247ea4ae5a36db18026c3a02e.png
[Scanner]: https://so.csdn.net/so/search?q=Scanner%E7%B1%BB&spm=1001.2101.3001.7020