03_Java基础语法_第3天（Scanner、Random、流程控制语句）

旧城等待， 2022-05-08 07:56 332阅读 0赞

今日内容介绍  
 引用数据数据类型（Scanner、Random）  
 流程控制语句（if、for、while、dowhile、break、continue）  
**切换盘符小技巧：**  
![在这里插入图片描述][70]

第1章 引用数据类型  
1.1 Scanner类  
我们要学的Scanner类是属于引用数据类型，我们先了解下引用数据类型。  
 引用数据类型的使用  
与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。  
数据类型 变量名 = new 数据类型();  
每种引用数据类型都有其功能，我们可以调用该类型实例的功能。  
变量名.方法名();  
 Scanner类  
Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。  
Scanner使用步骤：  
导包：import java.util.Scanner;

![在这里插入图片描述][70 1]  
创建对象实例：Scanner sc = new Scanner([System.in][]);  
调用方法：  
int i = sc.nextInt(); 用来接收控制台录入的数字  
String s = sc.next(); 用来接收控制台录入的字符串  
了解完Scanner类，我们编写代码来使用下它：ScannerDemo01.java

/*
    	引用数据类型，介绍一个类 Sacnnaer
    	java里已经存在，是Sun公司为我们做好的类，使用它就好
    	定义引用数据类型，和基本类型变量区别:
    	int a = 1
    	格式：
    		类型 变量名 = new 类型();
    	举例：创建出Sanner类的变量
    		Sacnnaer sc = new Sanner();
    	每个引用类型，都有自己的功能，如何使用功能
    	公式：
    		变量.功能名字()
    	
    	Scanner类的作用：让用户可以在命令行中，接受键盘的输入
    	使用Scanner类步骤：
    		1.导入包,指明类所在的文件夹，关键字import
    		  java文件夹-util文件夹
    		2.公式，创建出Scanner类型变量
    		3.变量，使用Scanner类中的功能，完成键盘的输入
    */
    //1.导入包,指明类所在的文件夹，关键字import java文件夹-util文件夹
    import java.util.Scanner;
    public class ScannerDemo{
    	public static void main(String[] args){
    		//类型 变量名 = new 类型();
    		//创建出Scanner类型变量
    		Scanner sc = new Scanner(System.in);
    		//变量.功能名字()接受键盘输入
    		//功能：nextInt() 接受键盘输入：必须保证输入的是整数
    		//功能接受的数据就是整数，功能运行以后的结果就是整数类型
    		int number = sc.nextInt();
    		// 为了验证接受来的整数类型 用运算验证（因为整数类型能进行整数相加减）
    		System.out.println(number + 1);
    		
    		//Scanner类的另一个功能 next() 可以接受键盘输入的字符串
    		String str = sc.next();
    		//任何类型与字符串相连 
    		//+ 任何类型只要和字符串+，所有数据都变成了字符串 间接证明这里str是字符串类型,而不是整数类型
    		System.out.println(str + 1);
    	}
    	
    }

![在这里插入图片描述][70 2]  
1.2 随机数类Random  
我们来学习下，用来产生随机数的类Random，它也属于引用数据类型。  
这个Random类，它可以产生多种数据类型的随机数，在这里我们主要介绍生成整数与小数的方式。  
 方法简介  
public int nextInt(int maxValue) 产生\[0,maxValue)范围的随机整数，包含0，不包含maxValue；  
public double nextDouble() 产生\[0,1)范围的随机小数，包含0.0，不包含1.0。

引用数据类型的使用方式，在学习键盘录入Scanner时，我们已经学习过，在这里，再次回顾一下：

 Random使用方式:  
 import导包：所属包java.util.Random  
 创建实例格式：Random 变量名 = new Random();  
![在这里插入图片描述][70 3]  
接下来，通过一段代码，一起学习下Random类的使用，RandomDemo.java

/*
    	java中已经有的引用类型 Random类：作用，产生随机数
    	步骤：
    		1.导入包，Random类，也在Java.util文件夹
    		2.公式：创建出Random类型的变量
    		3.变量，调用Random类中的功能，产生随机数
    		
    	Random类，提供功能，名字nextInt()产生一个随机数，结果是int类型出现随机数的范围
    	功能nextInt(写一个整数)，整数：随机出来的范围 随机数的范围在 0-指定的整数之间的随机数 
    	nextInt(100): 0-99
    	
    	产生浮点的随机数：功能名字nextDouble() 随机数的范围0.0-1.0之间  绝对不会到达1.0
    	
    	随机数：伪随机数，虚拟机根据人编写好的一个算法实现的
    */
    
    import java.util.Random;
    public class RandomDemo{
    	public static void main(String[] args){
    		//2 公式：创建出Random类型的变量
    		Random ran = new Random();
    		//3 变量，调用Random类中的nextInt,功能：产生随机数
    		int number = ran.nextInt(10);
    		System.out.println(number);
    		
    		//问题？ 产生随机数，范围在0-100之间
    		//nextInt(100) 0-99 +1
    		//nextInt(101)
    		
    		double d = ran.nextDouble();
    		System.out.println(d);
    	}
    	
    }

![在这里插入图片描述][70 4]  
第2章 流程控制语句  
2.1 选择结构if  
接下来要学习的if条件语句分为三种语法格式，每一种格式都有它自身的特点，下面我们分别进行介绍。  
2.1.1 if语句  
if语句是指如果满足某种条件，就进行某种处理。例如，小明妈妈跟小明说“如果你考试得了100分，星期天就带你去游乐场玩”。这句话可以通过下面的一段伪代码来描述。  
如果小明考试得了100分  
妈妈星期天带小明去游乐场  
在上面的伪代码中，“如果”相当于Java中的关键字if，“小明考试得了100分”是判断条件，需要用()括起来，“妈妈星期天带小明去游乐场”是执行语句，需要放在\{\}中。修改后的伪代码如下：  
if (小明考试得了100分) \{  
妈妈星期天带小明去游乐场  
\}  
上面的例子就描述了if语句的用法，在Java中，if语句的具体语法格式如下：

if (条件语句){ 
    	执行语句;
    	……
    }

上述格式中，判断条件是一个布尔值，当判断条件为true时，\{\}中的执行语句才会执行。if语句的执行流程如下图所示。  
![在这里插入图片描述][70 5]  
接下来通过一段代码，学习一下if语句的具体用法，IfDemo01.java

/*
    	if语句：
    		编写格式：
    		if(条件){
    			if语句的执行体
    		}
    		条件：结果必须是布尔类型 1 == 1 或者 true||false
    		执行体：当if中的条件为true的时候，执行大括号中的执行体
    				当if中的条件为false的时候，什么也不做
    */
    
    public class IfDemo{
    	public static void main(String[] args){
    		int i = 5;
    		//对变量i进行if判断
    		if(i == 5){
    			System.out.println("if中的条件是true");
    			i++;
    		}
    		System.out.println(i);
    		//这个一旦分号，就结束了，后面大括号肯定会实现
    		//所以if没有分号
    		if(i < 5);{
    			System.out.println("if中的条件是true");
    			i++;
    		}
    		System.out.println(i);
    	}
    	
    }

![if语句流程图][if]  
2.1.2 if…else语句  
if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。例如，要判断一个正整数的奇偶，如果该数字能被2整除则是一个偶数，否则该数字就是一个奇数。if…else语句具体语法格式如下：

if (判断条件){
    	执行语句1
    	……
    }else{
    	执行语句2
    	……
    }

上述格式中，判断条件是一个布尔值。当判断条件为true时，if后面\{\}中的执行语句1会执行。当判断条件为false时，else后面\{\}中的执行语句2会执行。if…else语句的执行流程如下图所示。  
![if…else语句流程图][if_else]

/*
    	if语句：
    		编写格式：
    		if(条件){
    			if语句的执行体
    		}else{
    			else的执行体
    		}
    		条件：结果必须是布尔类型 1 == 1 或者 true||false
    		执行体：当if中的条件为true的时候,执行if中的执行体
    				当if中的条件为false的时候,执行else的执行体
    */
    public class IfElseDemo{
    	public static void main(String[] args){
    		int i = 17;
    		//判断变量，是奇偶数，除以2，看余数
    		if(i % 2 == 0){
    			System.out.println(i + "是偶数");
    		}else{
    			System.out.println(i + "是奇数");
    		}
    	}
    	
    }

![在这里插入图片描述][70 6]  
2.1.3 if…else if…else语句  
if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。例如，对一个学生的考试成绩进行等级的划分，如果分数大于80分等级为优，否则，如果分数大于70分等级为良，否则，如果分数大于60分等级为中，否则，等级为差。if…else if…else语句具体语法格式如下：

if (判断条件1) {
    	执行语句1
    } else if (判断条件2) {
    	执行语句2
    }
    ...
    else if (判断条件n) {
    	执行语句n
    } else {
    	执行语句n+1
    }

上述格式中，判断条件是一个布尔值。当判断条件1为true时，if后面\{\}中的执行语句1会执行。当判断条件1为false时，会继续执行判断条件2，如果为true则执行语句2，以此类推，如果所有的判断条件都为false，则意味着所有条件均未满足，else后面\{\}中的执行语句n+1会执行。if…else if…else语句的执行流程如下图所示。  
![在这里插入图片描述][70 7]  
接下来通过一段代码，来实现对学生考试成绩进行等级划分的程序，IfDemo03.java

/*
    	if else if else语句：
    	适合在程序中，实现多条件的判断
    	编写格式：
    	if(条件){
    		if语句的执行体
    	}else if(条件){
    		if的执行体
    	}else if(条件){
    		if的执行体
    	}else{
    		else的执行体
    	}
    	条件：结果必须是布尔类型 1 == 1 或者 true||false
    	执行体：当if中的条件为true的时候,执行if中的执行体
    			当if中的条件为false的时候,执行else的执行体
    			一个语句中,包含有1个if的条件是true,其他的代码，不在执行
    */
    public class IfElseIfDemo{
    	public static void main(String[] args){
    		//成绩判断要求,成绩>80 成绩>70 成绩>60 不及格
    		//定义变量，保存成绩  分开写if语句,没有这种形式的效率好
    		int grade = 75;
    		if(grade > 80){
    			System.out.println(grade + "成绩是优");
    		}else if(grade > 70){
    			System.out.println(grade + "成绩是良");
    		}else if(grade > 60){
    			System.out.println(grade + "成绩是中");
    		}else{
    			System.out.println(grade + "成绩是不及格");
    		}
    	}
    	
    }

![在这里插入图片描述][70 8]  
2.1.4 选择结构if语句与三元运算转换  
三元运算符，它和if-else语句类似，语法如下：  
判断条件 ? 表达式1 : 表达式2  
三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。  
例如求两个数x、y中的较大者，如果用if…else语句来实现，具体代码如下：

/*
    	if语句和三元运算符的替换
    	要求：
    		已知两个数,计算最大值
    		两个整数,比较大小
    	使用if还是三元
    		判断条件多,使用if
    		三元,必须有结果,if可以没有结果的
    */
    public class IfElseDemo_1{
    	public static void main(String[] args){
    		int i = 5;
    		int j = 6;
    		//使用if语句，判断最大值
    		if(i > j){
    			System.out.println(i +"是最大值");
    		}else{
    			System.out.println(j +"是最大值");
    		}
    		
    		//使用三元运算实现
    		int k = i > j ? i : j;
    		System.out.println(k+"是最大值");
    		
    	}
    	
    }

![在这里插入图片描述][70 9]  
2.2 循环语句while  
while循环语句和选择结构if语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，\{\}内的执行语句就会执行，直到条件不成立，while循环结束。while循环语句的语法结构如下：

while(循环条件){
    执行语句
    ………
    }

在上面的语法结构中，\{\}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。  
while循环的执行流程如下图所示。  
![在这里插入图片描述][70 10]  
接下来通过一段代码，来实现打印1~4之间的自然数，WhileDemo.java

/*
    	循环语句：可以让一部分代码,反复执行
    	while循环：
    		编写格式：
    		
    		while(条件){
    			循环体
    		}
    		条件：当条件是true,执行循环体,执行完循环体后
    		程序再次执行while中的条件,如果条件还是true,继续执行循环体
    		直到条件是false的时候,循环就结束
    */
    public class WhileDemo{
    	public static void main(String[] args){
    		//输出1-4之间的整数
    		//定义变量,整数类型,循环的条件
    		int i = 1;
    		//while(i <= 4)
    		while(i < 5){
    			System.out.println(i);
    			i++;		
    		}
    	}
    }

![在这里插入图片描述][70 11]  
2.3 循环语句for  
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。for循环语句的语法格式如下：

for（初始化表达式; 循环条件; 操作表达式）{
    	执行语句
    	………
    }

在上面的语法结构中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，\{\}中的执行语句为循环体。  
接下来分别用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，通过序号来具体分析for循环的执行流程。具体如下：

for（① ; ② ; ③）{
    	④
    }
    第一步，执行① 变量定义，在整个循环中，终身只执行第一次
    第二步，执行②，条件，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
    第三步，执行④
    第四步，执行③，然后重复执行第二步
    第五步，退出循环

接下来通过一个案例对自然数1~4进行求和，如下所示。ForDemo01.java

public class ForDemo01 {
    	public static void main(String[] args) {
    		int sum = 0; // 定义变量sum，用于记住累加的和
    		变量定义 ②条件 ③增量
    		for (int i = 1; i <= 4; i++) { // i的值会在1~4之间变化
    			sum += i; // 实现sum与i的累加
    		}
    		System.out.println("sum = " + sum); // 打印累加的和
    	}
    }

![在这里插入图片描述][70 12]

/*
    	for循环
    	 编写格式
    		for(初始化变量;条件;增量){
    			循环体
    		}
    		初始化变量：定义变量，作用，控制循环的次数
    		条件：当条件是true,执行循环体,条件是false,结束循环
    		增量：变量自增情况
    */
    
    public class ForDemo{
    	public static void main(String[] args){
    		//for循环,输出0-10
    		for(int i = 0; i < 11; i++){
    			System.out.println(i);
    		}
    	}
    	
    }

![在这里插入图片描述][70 13]  
2.4 循环语句do…while  
do…while循环语句和while循环语句功能类似，其语法结构如下：

do {
    执行语句
    ………
    } while(循环条件);

在上面的语法结构中，关键字do后面\{\}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。  
do…while循环的执行流程如下图所示。  
![在这里插入图片描述][70 14]  
接下来使用do…while循环语句来实现打印1~4之间的自然数DoWhileDemo.java。

/*
    	do...while循环
    		编写格式：
    		do{
    			循环体
    		}while(条件)；
    	特点：无条件先执行一次循环体
    */
    
    public class doWhileDemo{
    	public static void main(String[] args){
    		int i = 0;
    		do{
    			System.out.println(i);
    			i++;
    		}while(i < 0);
    	}
    	
    }

![在这里插入图片描述][70 15]  
我们发现WhileDemo.java与DoWhileDemo.java运行的结果一致，这说明什么呢？这说明do …while循环和while循环能实现同样的功能。然而在程序运行过程中，这两种语句还是有差别的。如果循环条件在循环语句开始时就不成立，那么while循环的循环体一次都不会执行，而do…while循环的循环体还是会执行一次。若将DoWhileDemo.java中的循环条件x<=4改为x < 1，DoWhileDemo.java运行结果会打印x=1，而WhileDemo.java运行结果什么也不会打印。  
2.5 无限循环  
最简单无限循环格式：

while(true){} 
    或
    for(;;){}

无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。  
2.6 循环嵌套  
![在这里插入图片描述][70 16]  
![在这里插入图片描述][70 17]  
嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环，格式如下

for(初始化表达式; 循环条件; 操作表达式) {
    	………
    	for(初始化表达式; 循环条件; 操作表达式) {
    		执行语句
    		………
    	}
    	………
    }

接下来通过一个练习，来实现使用“\*”打印直角三角形，如下所示。ForForDemo.java

1	public class ForForDemo {
     2		public static void main(String[] args) {
     3			int i, j; // 定义两个循环变量
     4			for (i = 1; i <= 9; i++) { // 外层循环
     5				for (j = 1; j <= i; j++) { // 内层循环
     6					System.out.print("*"); // 打印*
     7				}
     8				System.out.print("\n"); // 换行
     9			}
     10		}
     11	}

/*
    	循环的嵌套：循环里面还有循环,for形式多
    		for(){
    			
    			for(){
    				
    				
    			}
    		}
    	总的循环次数 = 内循环次数 * 外循环次数
        内循环，是外循环的循环体	
    
    	外循环，控制的是行数
    	内循环，控制的是每行的个数
    */
    
    public class ForForDemo{
    	public static void main(String[] args){
    		for(int i = 1; i <= 9; i++){
    			for(int j = 0; j < i; j++){
    				System.out.print("* ");
    			}
    			System.out.println();
    		}
    	}
    	
    }

![在这里插入图片描述][70 18]  
2.7 跳转语句（break、continue）  
跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句。接下来分别进行详细地讲解。  
1、 break语句  
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。关于在switch语句中使用break前面的例程已经用过了，接下来通过下面一段代码，实现将当变量x的值为3时，使用break语句跳出循环，代码如下所示。BreakDemo.java

/*
    	break关键字
    	作用于循环中,终止循环的作用
    */
    
    public class BreakDemo{
    	public static void main(String[] args){
    		int i = 1;
    		while(i < 2000){
    			if(i == 3){
    				break;
    			}else{
    				System.out.println(i);
    			}
    			i++;
    		}
    	}
    	
    }

![在这里插入图片描述][70 19]  
2、 标记  
当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。接下来将ForForDemo.java稍作修改，控制程序只打印4行“\*”，如下所示。BreakDemo02.java

/*
    	break关键字
    	作用于循环中,终止循环的作用
    */
    
    public class BreakDemo_1{
    	public static void main(String[] args){
    		for(int i = 0; i < 2; i++){
    			for(int j = 0; j < 5; j++){
    				System.out.println("j=" + j);
    				//break 你放在那个循环里面,结束的就是那个循环
    				break;
    			}
    			System.out.println("i=" + i);
    		}
    		
    		System.out.println("for循环起名字");
    		a:for(int i = 0; i < 2; i++){
    			for(int j = 0; j < 5; j++){
    				System.out.println("j=" + j);
    				//或者你给for循环起名字,这样话,就能结束掉指定的循环
    				break a;
    			}
    			System.out.println("i=" + i);
    		}
    	}
    	
    }

![在这里插入图片描述][70 20]  
3、 continue语句  
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。接下来通过一个练习对1~100之内的奇数求和，ContinueDemo.java

/*
    	continue关键字
    	作用于循环中,终止本次循环,开始下一次循环
    */
    
    public class continueDemo{
    	public static void main(String[] args){
    		// 只打印奇数
    		for(int i = 0; i < 10; i++){
    			if(i % 2 == 0){
    				//continue终止本次循环,开始下一次循环
    				continue;
    			}
    			System.out.println(i);
    		}
    	}
    	
    }

![在这里插入图片描述][70 21]  
第3章 猜数字案例  
3.1 案例介绍  
我们在日常生活中，经常与朋友们玩猜数字的游戏，非常的有趣。现在我们通过java把这个猜数字游戏编写出来。  
猜数字案例是要完成什么样的功能呢？顾名思义，这个游戏就是你出个数字、我来猜。  
游戏操作如下：  
 后台预先生成一个1-100之间的随机数，用户键盘录入猜数字  
 如果猜对了，打印“恭喜您，答对了”  
 如果猜错了  
猜大了：打印“sorry，您猜大了!”  
猜小了：打印“sorry，您猜小了!”  
 直到数字猜到为止

在案例开始之前，我们先要学习如下知识点：  
 随机数类Random  
 选择结构if  
 循环结构while

3.2 案例需求分析、  
猜数字案例的需求如下：  
 后台预先生成一个1-100之间的随机数，用户键盘录入猜数字  
 如果猜对了，打印“恭喜您，答对了”  
 如果猜错了  
猜大了：打印“sorry，您猜大了!”  
猜小了：打印“sorry，您猜小了!”  
 直到数字猜到为止

我们经过分析，得出如下的分析结果：  
 1.通过Random类中方法nextInt（），生成一个1-100之间的随机数  
 2.输入猜的数字  
 3.通过while循环，进行猜数字对错判断  
 猜对，跳出循环，游戏结束  
 猜错了，根据结果，给出提示，接着猜数字，游戏继续  
 如果猜大了，打印sorry，您猜大了!继续下一次循环  
 如果猜小了，打印sorry，您猜小了!继续下一次循环  
3.3 实现代码步骤  
分析完毕之后，在main()方法中，我们一起来完成代码的编写：GuessNumber.java

/*
    	实现猜数字的小游戏：
    		随机数一个数字,让用户猜
    		结果三种情况：
    		猜对了 猜大了 猜小了
    	随机数：Random类
    	键盘输入：Scanner类
    	猜的数字,和随机数进行比较-if判断
    	直到猜中为止,反复去猜,循环while
    */
    import java.util.Random;
    import java.util.Scanner;
    public class GuestNumber{
    	public static void main(String[] args){
    		System.out.println("猜数字游戏开始");
    		System.out.println("请输入1-100之间的数字");
    		//创建Random类变量
    		Random ran = new Random();
    		//变量,使用功能nextInt()获取1-100的随机数
    		int ranNumber = ran.nextInt(100) + 1;
    		System.out.println("所猜的数字为：" + ranNumber);
    		//创建Scanner类变量
    		Scanner sc = new Scanner(System.in);
    		
    		while(true){
    			//获取键盘输入
    			int number = sc.nextInt();
    			//随机数和用户输入的数据比较
    			if(number > ranNumber){
    				System.out.println("猜大了");
    			}else if(number < ranNumber){
    				System.out.println("猜小了");
    			}else{
    				System.out.println("猜对了");
    				break;
    			}
    			
    		}
    	}
    
    	
    }

![在这里插入图片描述][70 22]

[70]: /images/20220508/13b48aff6e6044ab95a57c616969003e.png
[70 1]: /images/20220508/4900cb78aac847d78a616d18984ea010.png
[System.in]: http://System.in
[70 2]: /images/20220508/4ad66bc0c10e4d86976aade879575600.png
[70 3]: /images/20220508/e6e29069632b44478ba4416f13226f68.png
[70 4]: /images/20220508/6c8d5aaaf8174becab10566b1f25836f.png
[70 5]: /images/20220508/81f496b0a81942de8f18c32903200bdd.png
[if]: /images/20220508/0ef393a0c54a47fda15315a3e46b44a2.png
[if_else]: /images/20220508/46a392aeccac42b59641be4c1859b477.png
[70 6]: /images/20220508/f03991fae8fb40bfa4dd80cf44dc4acc.png
[70 7]: /images/20220508/800f647d79ea4455afb97e2778bd3a8d.png
[70 8]: /images/20220508/db3df2e28fc5473da11f94e759d85bbe.png
[70 9]: /images/20220508/0b11afeead004790aa3febd895f47297.png
[70 10]: /images/20220508/580c0386c8cd450da9cecc896d209470.png
[70 11]: /images/20220508/007b83a780df47c6978d323eac4b9e63.png
[70 12]: /images/20220508/1e9e550fe0cb4cfea3b6806489f59572.png
[70 13]: /images/20220508/0122641e00cf49d5888e05fcb9dc7632.png
[70 14]: /images/20220508/596199eb92274f1091e80fc3c866206c.png
[70 15]: /images/20220508/d96c1ffd32bd44f58448f46a7ebb17a9.png
[70 16]: /images/20220508/25b29ff9d0444f5eb2ba4509415887fe.png
[70 17]: /images/20220508/1f74bff483ee4e6ca3a3a94ea9fd0029.png
[70 18]: /images/20220508/1bd9c32c80d84ebd9cbcee8e68ec7657.png
[70 19]: /images/20220508/bf5c9c7fbd4548b0a091ac28b16bc299.png
[70 20]: /images/20220508/ef8398a768684f3eaa7610c5e76b00db.png
[70 21]: /images/20220508/44bf0a6e110446dda154e43faa9738b8.png
[70 22]: /images/20220508/b558293f783242bf897f56883a6d48a2.png