javaSE基础面向对象【上】（笔记）

心已赠人 2022-09-04 05:48 192阅读 0赞

### 面向对象【上】 ###

*  类与对象
 *  一 、基本思路
 *  二 、结构
 *  1.面向结构结构之一（属性）
 *  2. 面向结构结构之二（方法）
 *  (1)return 关键字
 *  （2）重载
 *  （3）可变个数的方法
 *  （4）java的值传递机制
 *  （5）递归
 *  （6）面向对象特征一（封装性）
 *  3.面向结构结构之三（构造器）
 *  （1）属性赋值顺序
 *  （2）javabean的概念
 *  （3）this关键字
 *  （4）package/import关键字1. package的使用

# 类与对象 #

# 一 、基本思路 #

1.面向对象学习的三条主线：

*  1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 *  
 *  2.面向对象的大特征：封装性、继承性、多态性、(抽象性)
 *  
 *  3.其它关键字：this、super、static、final、abstract、interface、package、import等
 *  
 *  “大处着眼，小处着手”

2.面向对象与面向过程（理解）  
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。  
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

举例对比：人把大象装进冰箱。

3.完成一个项目（或功能）的思路：

4.面向对象中两个重要的概念：  
类：对一类事物的描述，是抽象的、概念上的定义  
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

> 面向对象程序设计的重点是类的设计  
> 设计类，就是设计类的成员。

二者的关系：  
对象，是由类new出来的，派生出来的。  
5.面向对象思想落地实现的规则一

*  1.创建类，设计类的成员
 *  2.创建类的对象
 *  3.通过“对象.属性”或“对象.方法”调用对象的结构

补充：几个概念的使用说明

*  属性 = 成员变量 = field = 域、字段
 *  方法 = 成员方法 = 函数 = method
 *  创建类的对象 = 类的实例化 = 实例化类

6.对象的创建与对象的内存解析  
典型代码：  
Person p1 = new Person();  
Person p2 = new Person();  
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。  
说明：  
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）  
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 1]

7.匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象  
特点：匿名对象只能调用一次。  
举例：  
new Phone().sendEmail();  
new Phone().playGame();

new Phone().price = 1999;
    	new Phone().showPrice();//0.0

应用场景：  
PhoneMall mall = new PhoneMall();

//匿名对象的使用  
mall.show(new Phone());  
其中，  
class PhoneMall\{  
public void show(Phone phone)\{  
phone.sendEmail();  
phone.playGame();  
\}

\}  
8.理解"万事万物皆对象"  
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

*      >Scanner,String等
 *      >文件：File
 *      >网络资源：URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

JVM内存结构：  
编译完源程序以后，生成一个或多个字节码文件。  
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 2]  
《JVM规范》

虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中  
堆，我们将new出来的结构（比如：数组、对象）加载在对空间中。补充：对象的属性（非static的）加载在堆空间中。  
方法区：类的加载信息、常量池、静态域

# 二 、结构 #

# 1.面向结构结构之一（属性） #

类的设计中，两个重要结构之一：属性

对比：属性 vs 局部变量

1.相同点：

*      1.1  定义变量的格式：数据类型  变量名 = 变量值
 *      1.2 先声明，后使用
 *      1.3 变量都其对应的作用域

2.不同点：  
2.1 在类中声明的位置的不同

*      属性：直接定义在类的一对{}内
 *      局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *  
 *      2.2 关于权限修饰符的不同
 *      属性：可以在声明属性时，指明其权限，使用权限修饰符。
 *      常用的权限修饰符：private、public、缺省、protected  --->封装性
 *      目前，大家声明属性时，都使用缺省就可以了。
 *      局部变量：不可以使用权限修饰符。
 *  
 *      2.3 默认初始化值的情况：
 *      属性：类的属性，根据其类型，都默认初始化值。
 *      整型（byte、short、int、long：0）
 *      浮点型（float、double：0.0）
 *      字符型（char：0  （或'\u0000'））
 *      布尔型（boolean：false）
 *  
 *      引用数据类型（类、数组、接口：null）
 *  
 *      局部变量：没默认初始化值。
 *      意味着，我们在调用局部变量之前，一定要显式赋值。
 *      特别地：形参在调用时，我们赋值即可。
 *  
 *      2.4 在内存中加载的位置：
 *      属性：加载到堆空间中   （非static）
 *      局部变量：加载到栈空间

补充：回顾变量的分类：  
方式一：按照数据类型：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 4]

# 2. 面向结构结构之二（方法） #

类的设计中，两个重要结构之二：方法  
方法：描述类应该具的功能。

*  比如：Math类：sqrt()\\random() …
 *      Scanner类：nextXxx() ...
 *      Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
 *  
 *  1.举例：
 *  public void eat()\{\}
 *  public void sleep(int hour)\{\}
 *  public String getName()\{\}
 *  public String getNation(String nation)\{\}
 *  
 *  1.  方法的声明：权限修饰符 返回值类型 方法名(形参列表)\{
 *      方法体
 *      }
 *  注意：static、final、abstract 来修饰的方法，后面再讲。
 *  
 *  1.  说明：
 *      3.1 关于权限修饰符：默认方法的权限修饰符先都使用public

Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说  
\*

*      3.2 返回值类型： 返回值  vs 没返回值
 *      3.2.1  如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *      return关键字来返回指定类型的变量或常量：“return 数据”。
 *      如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
 *      使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 *  
 *      3.2.2 我们定义方法该不该返回值？
 *      ① 题目要求
 *      ② 凭经验：具体问题具体分析
 *  
 *      3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *  
 *      3.4 形参列表： 方法可以声明0个，1个，或多个形参。
 *      3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
 *  
 *      3.4.2 我们定义方法时，该不该定义形参？
 *      ① 题目要求
 *      ② 凭经验：具体问题具体分析
 *  
 *      3.5 方法体：方法功能的体现。

1.  方法的使用中，可以调用当前类的属性或方法

*      特殊的：方法A中又调用了方法A:递归方法。
 *      方法中，不可以定义方法。

# (1)return 关键字 #

return关键字：  
1.使用范围：使用在方法体中  
2.作用：① 结束方法

*      ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。

3.注意点：return关键字后面不可以声明执行语句。

# （2）重载 #

1.方法的重载的概念  
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。  
\*  
总结：“两同一不同”:同一个类、相同方法名  
参数列表不同：参数个数不同，参数类型不同

构成重载的举例：  
举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()  
举例二：  
//如下的4个方法构成了重载  
public void getSum(int i,int j)\{  
System.out.println(“1”);  
\}

public void getSum(double d1,double d2){
    	System.out.println("2");
    }
    
    public void getSum(String s ,int i){
    	System.out.println("3");
    }
    
    public void getSum(int i,String s){
    	System.out.println("4");
    }

不构成重载的举例：  
//如下的3个方法不能与上述4个方法构成重载  
// public int getSum(int i,int j)\{  
// return 0;  
// \}

// public void getSum(int m,int n)\{  
//  
// \}

// private void getSum(int i,int j)\{  
//  
// \}  
3. 如何判断是否构成方法的重载？  
严格按照定义判断：两同一不同。  
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！  
4.如何确定类中某一个方法的调用：  
方法名 —> 参数列表

面试题：方法的重载与重写的区别？

throws\\throw  
String\\StringBuffer\\StringBuilder  
Collection\\Collections  
final\\finally\\finalize  
…

抽象类、接口  
sleep() / wait()

# （3）可变个数的方法 #

1.使用说明：

*  1.jdk 5.0新增的内容
 *  2.具体使用：
 *  2.1 可变个数形参的格式：数据类型 … 变量名
 *  2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *  2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *  2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *  2.5 可变个数形参在方法的形参中，必须声明在末尾
 *  2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.举例说明：  
public void show(int i)\{

}
    
    public void show(String s){
    	System.out.println("show(String)");
    }
    
    public void show(String ... strs){
    	System.out.println("show(String ... strs)");
    	
    	for(int i = 0;i < strs.length;i++){
    		System.out.println(strs[i]);
    	}
    }
    //不能与上一个方法同时存在

// public void show(String\[\] strs)\{  
//  
// \}  
调用时：  
test.show(“hello”);  
test.show(“hello”,“world”);  
test.show();

test.show(new String[]{"AA","BB","CC"});

# （4）java的值传递机制 #

1.针对于方法内变量的赋值举例

System.out.println("***********基本数据类型：****************");
    		int m = 10;
    		int n = m;
    		
    		System.out.println("m = " + m + ", n = " + n);
    		
    		n = 20;
    		
    		System.out.println("m = " + m + ", n = " + n);
    		
    		System.out.println("***********引用数据类型：****************");
    		
    		Order o1 = new Order();
    		o1.orderId = 1001;
    		
    		Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
    		
    		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
    		
    		o2.orderId = 1002;
    		
    		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
    
    > 规则： 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
    2.针对于方法的参数概念
    形参：方法定义时，声明的小括号内的参数
    实参：方法调用时，实际传递给形参的数据

3.java中参数传递机制：值传递  
规则：

*  如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 *  如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：  
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。  
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

4.典型例题与内存解析：  
【例题1】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 6]

# （5）递归 #

1.定义：  
递归方法：一个方法体内调用它自身。  
2.如何理解递归方法？

> 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。  
> 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。  
> 3.举例：

// 例1：计算1-n之间所自然数的和
    	public int getSum(int n) { // 3
    
    		if (n == 1) { 
    			return 1;
    		} else { 
    			return n + getSum(n - 1);
    		}
    
    	}
    
    	// 例2：计算1-n之间所自然数的乘积:n!
    	public int getSum1(int n) { 
    
    		if (n == 1) { 
    			return 1;
    		} else { 
    			return n * getSum1(n - 1);
    		}
    
    	}
    	
    	//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
    	//其中n是大于0的整数，求f(10)的值。
    	public int f(int n){ 
    		if(n == 0){ 
    			return 1;
    		}else if(n == 1){ 
    			return 4;
    		}else{ 
    // return f(n + 2) - 2 * f(n + 1);
    			return 2*f(n - 1) + f(n - 2);
    		}
    	}
    
    	//例4：斐波那契数列
    	
    	//例5：汉诺塔问题
    	
    	//例6：快排

# （6）面向对象特征一（封装性） #

面向对象的特征一：封装与隐藏  
1.为什么要引入封装性？  
我们程序设计追求“高内聚，低耦合”。  
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；  
低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入：  
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).  
–>此时，针对于属性就体现了封装性。  
3.封装性思想具体的代码体现：  
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值  
private double radius;  
public void setRadius(double radius)\{  
this.radius = radius;  
\}  
public double getRadius()\{  
return radius;  
\}  
体现二：不对外暴露的私有的方法  
体现三：单例模式（将构造器私有化）  
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.Java规定的四种权限修饰符  
4.1 权限从小到大顺序为：private < 缺省 < protected < public  
4.2 具体的修饰范围：  
![在这里插入图片描述][a2066cbefadb4db88869c55c0a298d82.png]

4.3 权限修饰符可用来修饰的结构说明：  
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类  
修饰类的话，只能使用：缺省、public

# 3.面向结构结构之三（构造器） #

1.构造器（或构造方法）：Constructor  
构造器的作用：

*  1.创建对象
 *  2.初始化对象的信息  
    2.使用说明：
 *  1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 *  2.定义构造器的格式：权限修饰符 类名(形参列表)\{\}
 *  3.一个类中定义的多个构造器，彼此构成重载
 *  4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
 *  5.一个类中，至少会有一个构造器。

3.举例：

//构造器
    	public Person(){ 
    		System.out.println("Person().....");
    	}
    	
    	public Person(String n){ 
    		name = n;
    		
    	}
    	
    	public Person(String n,int a){ 
    		name = n;
    		age = a;
    	}

# （1）属性赋值顺序 #

*  总结：属性赋值的先后顺序
 *  
 *  
 *  ① 默认初始化
 *  ② 显式初始化
 *  ③ 构造器中初始化

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

*  ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
 *  
 *  以上操作的先后顺序：① - ② - ③ - ④

# （2）javabean的概念 #

所谓JavaBean，是指符合如下标准的Java类：
    	>类是公共的
    	>一个无参的公共的构造器
    	>属性，且对应的get、set方法

# （3）this关键字 #

1.可以调用的结构：属性、方法；构造器  
2.this调用属性、方法：  
this理解为：当前对象 或 当前正在创建的对象

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，

*  通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
 *  的使用"this.变量"的方式，表明此变量是属性，而非形参。
 *  
 *  2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器：  
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器  
② 构造器中不能通过"this(形参列表)“方式调用自己  
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”  
④ 规定："this(形参列表)“必须声明在当前构造器的首行  
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

# （4）package/import关键字1. package的使用 #

1.1 使用说明：

*  1.为了更好的实现项目中类的管理，提供包的概念
 *  2.使用package声明类或接口所属的包，声明在源文件的首行
 *  3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
 *  4.每"."一次，就代表一层文件目录。  
    1.2 举例：  
    举例一：  
    某航运软件系统包括：一组域对象、GUI和reports子系统  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 7]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 8]  
    1.3 JDK中的主要包介绍：  
    1.3 JDK中的主要包介绍：

1.  import的使用：  
    import:导入

*  1.  在源文件中显式的使用import结构导入指定包下的类、接口
 *  1.  声明在包的声明和类的声明之间
 *  1.  如果需要导入多个结构，则并列写出即可
 *  1.  可以使用"xxx.\*"的方式，表示可以导入xxx包下的所结构
 *  1.  如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 *  1.  如果使用的类或接口是本包下定义的，则可以省略import结构
 *  1.  如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
 *  1.  使用"xxx.\*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
 *  
 *  1.  import static:导入指定类或接口中的静态结构:属性或方法。

1.  import的使用：  
    import:导入

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70]: /images/20220829/320dfb9fa378436da6ba794ca45d9ab2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 1]: /images/20220829/62e2b0c830904fdfb5fd655d2a4796f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 2]: /images/20220829/297a0a91198d41e2ae166acbf6dc7d8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 3]: /images/20220829/0e1d5b0d58ea48d0a1f49fb151d40ebc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 4]: /images/20220829/80fb1aeb665a41c2bfd64be17147fd67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 5]: /images/20220829/aec51efb14ff498fbbe397a2cddc8eca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 6]: /images/20220829/ce2d7caa245c4bada467d9ee42f4da2b.png
[a2066cbefadb4db88869c55c0a298d82.png]: /images/20220829/f8d080850fd846f0b4ba892e78edefe5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 7]: /images/20220829/88d9ebeb8a2949eea6e088105620c9f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmFuYzEzNw_size_16_color_FFFFFF_t_70 8]: /images/20220829/e9a2841cd757452caf74a722f07150cf.png