java第六章学习笔记:对象和类---java世界的细胞

本是古典何须时尚 2022-05-30 12:37 373阅读 0赞

【因为每一章都篇幅比较长（10多页，难免有的地方会写错字，如发现请指正，本人不胜感激）】

本章介绍面向对象理念以及如何通过类创建对象

## 6.1 面向对象概述 ##

主要包括面向对象诞生，面向过程与面向对象程序设计思想的对比，面向对象技术的背景和特点；  
提示：面向对象（Object Oriented简称oo）java是完全面向对象语言  
6.1.1 面对对象程序设计思想的诞生  
【对象不再仅仅与名词相联系，还包括事件和过程】  
1、1966年，开发了具有更高级抽象机制的Simula语言。  
2、Simula语言提供了比子程序更高一级的抽象和封装，并且为仿真一个实际问题，引入了数据抽象和类的概念，后来PARC一些科学家在吸取了Simula类的概念，开发了Smailtalk语言  
3、大约在同时，”面对对象“这一术语正式确定，在Smailtalk中一切都是对象—即某个类的实例，最初的Smailtalk中对象与名词紧紧相连。  
4、Smailtalk语言还影响和20世纪80年代早期和中期的很多面向对象语言，eg：Object-c(19860),C++(1986),Self（1987），Eiffel（1987），Flavors(1986),同时面对对象应用领域进一步扩宽，对象不再仅仅与名词相联系，还包括事件和过程。  
5、sun公司于1995年推出了纯面向对象的java语言  
说明：Smailtalk被认为是第一个真正面向对象语言。  
6.1.2 面向对象和面向过程思想对比  
传统面向过程的程序设计通过设计一系列的过程（即算法）来求解问题，这些过程一旦被确定，下一步就要寻找存储数据的方式，即“程序=算法+数据结构”，其中算法是第一位，而数据结构是第二位，而oop调换了这个次序，将数据放在第一位，然后再考虑操纵数据的算法。  
提示：OOP是Object Oriented Programming的缩写，即面向对象的程序设计  
在oop中，程序被看做是相互协作的对象集合，每个对象都是某个类的实例，所有类构成一个通过几成关系相联系的层次结构。面对对象的语言常有以下特征：  
1、对象生成功能  
2、消息传递机制  
3、类和遗传机制  
只有在面对对象语言中，以上的三个机制才共同出现，并以一种独特的合作方式相互协作，互相补充。实际上，软件开发的过程就是人们在使用各种计算机语言将自身关心的现实世界（或问题域）映射到计算机世界的过程，这个过程通常如下图所示：  
![这里写图片描述][70]  
1、面对过程的编程模式：  
在这种编程模式中，数据和函数（过程）是分开的，即开发人员看到的是函数或过程的集合以及单独的一批数据，程序的处理过程为：参数输入->函数/过程代码->结果输出，如图：  
![这里写图片描述][70 1]  
图 6-2 面向过程的编程模式  
图中的”F(1)”,”F(2)”,”F(3)”表示函数（过程），细线箭头表示函数（过程）对数据的访问。  
对维护人员来说无论是函数还是数据结构的改动都会使整个程序受到干扰，进而导致软件系统的崩溃  
并且，在这种模式中，程序员分析了问题之后，得到一个面向过程的模型，其中常见的词语是变量，函数，过程等。其过程如下图所示：  
![这里写图片描述][70 2]

2、面向对象的编程方式
    在这种模式中，函数和它需要存取的数据封装在称为对象的单元中，对象之间的访问是间接的，是通过接口执行的。这里所说的接口指：为其他代码调用提供的一套访问方法，也就是API,其编程模式如图：

![这里写图片描述][70 3]  
1、图中的每个圆表示一个对象，细线箭头表示对象间的消息（调用）  
2、通常将对象比作鸡蛋，蛋黄是数据，蛋清是访问数据的函数，蛋壳表示接口（即那些公开的或公布的方法和属性）  
3、蛋壳接口隐匿了函数和数据结构的实现，当数据结构和内部函数时，这种变化被限制在内部的局部范围内，由于接口具有相对稳定性，使得这种内部变化的影响不会波及到其他对象，除非蛋壳破裂（接口发生变化）  
在面向对象编程模式中，程序的功能是通过对象间的通信获得的，对象被定义为一个封装了状态（数据）和行为（操作）的实体  
1、状态包含了执行行为的信息，它以数据形式存储于对象之中；  
2、消息是对象通信的方式，因而也是获得功能的方式，对象收到发给它的消息后，或者执行 一个内部操作或者再去调用其他对象的操作。在面向对象的编程模式中，开发人员首先得到一个面向对象的模型，其中常见的词语是类、对象、方法、消息等，基本过程如图：  
![这里写图片描述][70 4]  
6.1.3 面对对象技术的背景和特点  
oo是一种方法、一种思想，一种技术，比如，认识“苹果”形成苹果的概念以后，这个概念会一直存在人们思维中，不会因为这个苹果被吃掉而不存在。每个对象都有自己的运动规律和内部状态，不同对象之间相互联系相互作用。  
2、面对对象技术的特点：  
1、某类对象是对现实世界具有共同特性的某类事物的抽象；  
2、对象蕴含许多信息可以用一组属性来表示  
3、对象内部含有数据和对数据的操作  
4、对象之间是相互关联和相互作用的  
所以面对对象的特点为：抽象性、继承性、封装性、多态性  
从开发角度：对象就是协调数据存储以及作用于数据之上操作的数据实体，用户可以通过定义一个对象集合以及它们之间相互作用来创建一个面向对象程序，许多对象协同工作来定义一个完成用户需要的软件系统

## 6.2 类的定义和对象的创建 ##

类决定了某一对象的外观和行为，类是构造对象的模板或蓝图，对象只有在程序运行 时才产生；  
类声明是用来创建对象的模板的抽象规格说明

public class Student //类声明
    {
    //定义方法和成员变量
    }

由类创建对象的过程称为**实例化**，每个对象是一个类的实例eg:  
![这里写图片描述][70 5]  
学生类是对什么是学生的一个定义，而张三、李四、王五是对象，是学生类的实例。

## 6.3 成员变量 ##

成员变量与成员方法，成员变量的开发和使用、初始值以及对象引用变量的比较

6.3.1 成员变量的开发与使用  
成员变量就是类的属性，也称实例变量eg:

public class Student //类声明
    {
        //定义方法和成员变量
        String sname;
        int sage;
        String sclass;
    
    }

public class Test39 
    {
        public static void main(String args[])
        {
            Student Tom;
            Tom=new Student();
            Student Marry=new Student();
            Tom.sage=21;
            Tom.sclass="5788";
            Marry.sage=20;
            Marry.sclass="7890";
            Tom.sname="Tom";
            Marry.sname="herry";
            System.out.println("姓名："+Tom.sname+",年龄："+Tom.sage+",所在班级："+Tom.sclass);
            System.out.println("姓名："+Marry.sname+",年龄："+Marry.sage+"，所在班级："+Marry.sclass);
        }
    }

运行结果：  
![这里写图片描述][70 6]  
6.3.2 成员变量的初始值  
创建一个对象后，若对象有成员变量，则系统会自动为其分配一个初始值，下表给出了基本数据类型和对象引用类型成员变量的初始值；  
![这里写图片描述][70 7]  
eg:  
![这里写图片描述][70 8]  
对对象引用类型的成员变量，其初始值为“null”,表示此引用没有指向任何对象

*  提示：要特别注意String类型的空引用（null）与空字符串不同，空引用表示没有指向任何对象，空字符串是内容为空的字符串对象
    
    6.3.3 对象引用变量的比较  
    **对象引用变量**一般简称为引用，其值代表的就是对象的地址（联系方式），可以进行等于、不等于比较，其比较的含义是：**比较两个引用是否指向同一个对象**，而不是比较对象是否等价【比较两个对象等价的方法为equals】eg：

public class Test39 
    {
        int intMember=88;
        public static void main(String args[])
        {
            Test39 test1=new Test39();
            Test39 test2=new Test39();
            System.out.println("打印两个对象的值：");
            System.out.println("test1.intMember="+test1.intMember+",test2.intMember="+test2.intMember);
            if(test1==test2)//对引用变量进行比较
            {
                System.out.println("test1与test2指向同一个对象");
            }else
            {
                System.out.println("test1与test2不是指向同一个对象");
            }
            test1=test2;
            if(test1==test2)//对引用变量进行比较
            {
                System.out.println("test1与test2指向同一个对象");
            }else
            {
                System.out.println("test1与test2不是指向同一个对象");
            }
        }
    }

运行结果：  
![这里写图片描述][70 9]  
第一次比较两个引用返回false，第二次时test2的值赋给了test1，所以两个引用就指向了同一个对象咯。  
![这里写图片描述][70 10]

## 6.4 方法 ##

对对象的操作即为*方法*  
方法实际上描述的而是一个行为，一个功能。其决定了对象能接受到什么样的消息，做出什么反应。  
方法的基本组成包括：声明和方法体

1.  参数列表：要传递什么样的信息给方法  
    包含类名和变量标识符eg String data  
    方法的参数实际上也是一种局部变量，其作用域（作用范围）为整个方法体。
2.  方法体  
    完成一定的功能和行为
3.  返回值类型：  
    返回结果的类型  
    返回值和方法返回类型之间的规则：  
    1、返回引用类型的方法中可以返回null,但当基本数据类型作为返回类型时，不可以返回null  
    2、对象作为返回值也是合法的，eg数组  
    3、void方法没有返回值  
    4、返回引用类型时可以返回任何引用，只要返回的和返回类型可以自动转化就行 ；基本数据类型也是double的返回13也是ok 的啦；  
    java的方法存在于类体中，只能通过引用来调用格式：引用名.方法名（接收参数序列）；
    
    ## 6.5 变长参数（可变参数） ##
    
    即方法参数的个数是不定的 eg:

import java.util.Arrays;
    public class Test39 
    {
        public static void main(String args[])
        {
            int[] iarray={
       4,2,3,6,77,45,66,99,88};
            sortArray(iarray);  
        }
        //对数组排序
        public static void sortArray(int[] intarray)
        {
            Arrays.sort(intarray);//对数组排序
            int size=intarray.length;
            System.out.println("遍历排序后的数组：");
            for(int i:intarray)
            {
                System.out.print(i+" ");
            }
    
        }
    }

运行结果：  
![这里写图片描述][70 11]  
两个方法都是static，所以不需要new 类对象，通过类对象调用，但是不同类中需要类来调用，类名.方法名  
但是以上的代码实现对于非特定的数组不现实，所以java SE5.0以后提供了变长参数的新特征，能开发出真正接收任意个参数的方法eg:

import java.util.Arrays;
    public class Test39 
    {
        public static void main(String args[])
        {
            //直接将数组元素写在方法参数中
            sortAndPrint(4,2,3,6,77,45,66,99,88,33,43,23,1);
        }
        //对数组排序 ，entrys是变长参数名
        public static void sortAndPrint(int... entrys)
        {
            Arrays.sort(entrys);//对数组排序
            int size=entrys.length;
            System.out.println("优化后可变数组遍历排序后的为：");
            for(int i:entrys)
            {
                System.out.print(i+" ");
            }
    
        }
    }

运行结果：  
![这里写图片描述][70 12]  
使用变长参数时，有如下规则：  
1、一个方法最多只能有一个可变参数  
2、如果方法的参数不止一个，那么可变参数必须放在最后；  
可变参数的本质还是一个数组

## 6.6 引用问题 ##

无论是访问对象的成员变量还是方法，都必须通过对象引用，包含：调用不存在 的方法或成员变量，用空引用进行调用或数组的空引用问题  
6.6.1 调用不存在的方法或成员变量  
若想试图通过引用调用其所在类中没有定义的方法会报错  
6.6.2 用空引用进行调用（值为null的引用）  
即为此引用没有指向任何对象，而方法和成员变量都是属于对象的eg:  
当没给test任何值的时候：  
![这里写图片描述][70 13]  
当给test为null以后：  
![这里写图片描述][70 14]  
**开发时一定要注意引用不能为null**  
6.6.3 数组的空引用问题  
在java中数组也是对象，访问数组必须通过指向数组对象的引用，数组元素按照下标访问的，但其实数组元素可以看做是成员变量，只不过普通对象的成员变量用名称访问，而数组的成员变量用下标访问  
So 用空的数组引用访问元素也会抛出引用为空的异常eg:  
![这里写图片描述][70 15]  
\#\# 6.7 局部变量 \#\#  
局部变量定义在语句块中，包含局部变量的作用域与局部变量的初始化  
\- 提示：诸如方法体、循环体、if或else后面的一对花括号等，都是语句块，但是**类体不是**  
6.7.1 局部变量作用域  
局部变量：只在局部有效即只在一个语句块内有效（eg:村长），其生命周期是从开始执行 声明他的语句开始,到其所在的语句块结束而结束。  
\- 说明：一个语句块指用一对花括号包含的任意句代码，语句块可以嵌套  
\- 注意：同一个局部，同名的局部变量只能有一个

eg:  
![这里写图片描述][70 16]  
第6行定义的a作用域到第11行，第10行定义的a作用域到11行，所以重复。但是若不声明（去掉int）直接赋值是可以的  
6.7.2 局部变量初始化  
**局部变量与成员变量不同，声明以后不初始化，系统不会给其赋初值**，若使用没有初始化的局部变量则会报错。  
1、基本数据类型局部变量  
2、对象引用类型局部变量  
1、基本数据类型局部变量：  
局部变量声明和初始化可以在不同代码行上，但在使用局部变量之前必须初始化eg:  
![这里写图片描述][70 17]  
令人困扰的例子：  
![这里写图片描述][70 18]  
原因：编译时编译器不能断定执行时的具体情况，虽然if肯定返回true，但是比较的时候编译器只能看到x、y两个变量，具体值编译器无法知道  
如果条件表达式改为“true”或者“55<66”等字面常量表达式时那么该代码就能编译运行【理解编译器和运行时所作工作的不同】  
2、对象引用类型局部变量：  
局部引用与成员引用不同，对于成员引用，系统会自动分配初始值，为保证正确，只需要在使用前检查引用是否为null就行，但是局部引用系统不会分配初始值，所以局部引用检查是否为null是没用的。  
![这里写图片描述][70 19]  
想要使用str的话，直接将第六行增加null就行

## 6.8 this预定义对象引用 ##

对象在自己的方法中应该可以访问自己的成员变量，eg:

class Test39 { 
        public static void main(String args[])
        {
            new Person().showAge();
        }   
    }
    class Person { 
        String name="lili";
        int age=21;
        void showAge()
        {
            System.out.println("访问了Student来的name:"+name+",以及年龄："+age);
        }
    }

运行结果：  
![这里写图片描述][70 20]  
提示：若某个对象只被访问一次，可以直接new操作后调用其方法或成员变量而不必将new的返回值赋给一个引用，**因为new操作的返回值就是所创建对象的引用**  
如果成员变量与局部变量同名，调用时如何处理？eg:

class Test39 { 
        public static void main(String args[])
        {
            new Person().showAge();
        }   
    }
    class Person { 
        String name="Anne";
        int age=21;
        void showAge()
        {
            int age=22;
            String name="Amy";
            System.out.println("成员变量与局部变量同名时基本数据类型选择："+age+"引用类型选择："+name);//都是局部变量值
        }
    }

运行结果：  
![这里写图片描述][70 21]  
当局部变量与成员变量同名时，系统访问局部变量，若要访问成员变量，此时就要用到预定义对象引用this，this在任何一个方法中使用，表示指向对象自己的引用。  
提示：  
**this只能在属于对象的方法或语句块中使用，像诸如main这样static修饰的方法则不可以用this**详细解释在第七章static中，对象的语句块参照第10章内容  
![这里写图片描述][70 22]  
just添加了this而已。（厉害吧，想换哪个换哪个）

## 6.9 擅用系统已有的类 ##

java类库中提供的几个常用的处理日期时间的类，目的：了解擅用系统已有类的思想；  
6.9.1 Java中的Date类  
使用Date类时，需要在代码开始处添加“import java.util.Date”  
Date类与第三章的Math类不同，在开发中不是访问类的静态方法，而是要使用其对象，可以用如下代码创建Date对象。

//创建表示当前系统时间的Date对象
    new Date();
    //创建表示2006年12月8日日期的Date对象
    new Date(106,11,8);

Date对象中存放的是对象创建时的系统时间

import java.util.Date;
    class Test39 
    {
        public static void main(String args[])
        {
            //创建表示当前系统时间的Date对象
            new Date();
            //创建表示2006年12月8日日期的Date对象
            new Date(106,11,8);//106表示2006,11表示12月
            System.out.println("当前系统时间为："+new Date());
            System.out.println("昨天时间为："+new Date(128,2,12));//获得昨天时间
        }   
    }
    class Person
    {
        String name="Anne";
        int age=21;
        void showAge()
        {
            int age=22;
            String name="Amy";
            System.out.println("成员变量与局部变量同名时基本数据类型选择："+this.age+"引用类型选择："+this.name);//都是局部变量值
        }
    }

运行结果 ：  
![这里写图片描述][70 23]  
一定不能忘记写import！！  
Date中的操作时间的方法：  
1、boolean after(Date when)  
此方法用于测试此日期是否在指定日期之后，其参数为Date对象，返回boolean型，当且仅当Date对象表示的瞬间比when表示的瞬间晚，返回true，否则返回false,eg：

Date birthday=new Date();
            Date today=new Date();
            if(birthday.after(today))
            {
                System.out.println("today is early then birthday");
    
            }

2、boolean before(Date when)  
此方法与上述方法对应，用于测试此日期是否在指定日期只爱你，参数为一个Date对象，返回boolean型，当且仅当Date对象表示的瞬间比when表示的瞬间早，返回true “eg:

Date birthday=new Date();
            Date today=new Date();
            if(birthday.before(today))
            {
                System.out.println("today is later then birthday");
    
            }

3、提取时间的方法：  
![这里写图片描述][70 24]  
使用demo:

import java.util.Date;
    public class Test
    {
        public static void main(String[] args)
        {
            Date now=new Date();
            int year=now.getYear()+1900;//获取当前年份
            int month=now.getMonth()+1;//获取当前月份
            int date=now.getDate();
            String day="";
            switch (now.getDay())
            {
                case 0:
                    day="星期日";
                    break;
                case 1:
                    day="星期一";
                    break;
                case 2:
                    day="星期二";
                    break;
                case 3:
                    day="星期三";
                    break;
                case 4:
                    day="星期四";
                    break;
                case 5:
                    day="星期五";
                    break;
                case 6:
                    day="星期六";
                    break;
            }
            int hour=now.getHours();
            int temp=now.getMinutes();
            int sec=now.getSeconds();
            System.out.println("现在的时刻为："+year+"年"+month+"月"+date+"日"+day+","+hour+"时"+temp+"分"+sec+"秒");
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
![这里写图片描述][70 25]  
这里的API已过时，这里的大部分提取时间的方法有了更好的替代方法，可查阅API

6.9.2 java中的GregorianCalendar类  
上一节介绍Date类，其主要功能是存储当前时间点的信息，而对日期、时间处理的功能并不强大，其记录的时间是距离一个固定时间点的毫秒数（可正可负）这个固定时间点是UTC时间1970年1月1日 00:00：00（UTC是Coodinated Universal Time的缩写，其与GMT一样是一种国际标准时间）  
虽然Date可以打印出类似于“February 17,2017,23:59:59 GMT”这样的日期表示形式，但此形式只是阳历的表示方式，若需要农历日期Date类就无能为力了。  
最好使用不同类表示不同的概念：  
用来表示时间点信息的Date类  
用来表示人们所熟悉的阳历表示法的GregorianCalendar  
GregorianCalendar可以想Date类一样创建一个表示当前时间的GregorianCalendar对象eg:

import java.util.GregorianCalendar;
    
    new GregorianCalendar(2018,3,13);

因为月份范围从0开始，所以上述日期为2018年4月，为了清晰也可以使用常量：

new GregorianCalendar(2018, Calendar.FEBRUARY,17);

同时也可以在创建对象时给出具体时间信息：

new GregorianCalendar(2018, Calendar.FEBRUARY,17,18,15,23);

上面创建的对象存储的时间为：2018年2月17日18时15分23秒  
提示：java中对于不便于记忆的一些数值往往涉及为类的最终属性（常量）来表示，比如Math.PI和这里的Calendar.FEBRUAY等，Calendar类中还有很多有用的常量：下表列出GregorianCalendar类中的一些常用的方法：  
![这里写图片描述][70 26]  
使用demo:

import java.util.Calendar;
    import java.util.Date;
    import java.util.GregorianCalendar;
    
     class Test39
    {
         public static void main(String[] args)
        {
            GregorianCalendar now=new GregorianCalendar();
            Date date=now.getTime();//从当前时期对象中取出时间日期对象
            System.out.println(date.toString());
            now.setTime(date);//重新将时间对象设置到日期对象中
            int today=now.get(Calendar.DAY_OF_MONTH);//从日期对象中取出月份和日期
            int month=now.get(Calendar.MONTH);
            now.set(Calendar.DAY_OF_MONTH,1);//设置日期为本月开始日期
            int week=now.get(Calendar.DAY_OF_WEEK);//获取本月开始日期在一周中的编号
            System.out.println("星期日 星期一 星期二 星期三 星期四 星期五 星期六");//打印日历头
            for(int i=Calendar.SUNDAY;i<week;i++) {
                System.out.print(" ");
                while (now.get(Calendar.MONTH) == month)//按规格循环打印当前月的日期数字
                {
                    int day = now.get(Calendar.DAY_OF_MONTH);//设置当前日期
    
                    if (day < 10)//设置小于10 和不小于10的两种打印规格(因为小于10的是一位数)
                    {
                        if (day == today) {
                            System.out.print("<" + day + "> ");
                        } else
                            System.out.print(" " + day + " ");
                    } else {
                        if (day == today) {
                            System.out.print("<" + day + "> ");
                        } else
                            System.out.print(" " + day + " ");
                    }
                    if (week == Calendar.SUNDAY)//设置什么时候换行
                    {
                        System.out.println();
                    }
                    now.add(Calendar.DAY_OF_MONTH, 1);
                    week = now.get(Calendar.DAY_OF_WEEK);
                }
            }
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
GregorianCalendar类对日期的处理功能要比Date类强大很多  
提示：java中只提供了对阳历的实现—GregorianCalendar类，阴历的等其他处理类型的日历可以扩展java.util.Calendar类  
6.9.3 擅用系统已有类的思想  
系统中已提供的类，不必自己重新创造，开发程序时，首先寻找已有的解决方案，如果没有再自己开发。  
自己开发时也是，同样的代码仅出现一次即可，之后可以无限次的调用，这样设计出来的代码可维护性很高，而且开发的工作也相对很少，否则某天发现一个bug,导出修改是一件非常令人厌烦的工作而且没有意义。  
eg:在开发过程中，若有很多位置需要使用同样的功能，就需要将此功能拿出来单独开发一个方法，这样在需要此功能时调用该方法即可，若需要改进，只需要改进一处代码。

第六章完！【成长的速度要赶得上父母老去的速度】

![这里写图片描述][70 27]

[70]: /images/20220530/1c60a276979d4eb781f5a4032028fefe.png
[70 1]: /images/20220530/6ed4f53152a9438a8cd2eea4f97c548b.png
[70 2]: /images/20220530/d7a2b6f4f3994b9abddeba2534662bcb.png
[70 3]: /images/20220530/5f15d96c2e9c40bdb2bc79fab8f4daba.png
[70 4]: /images/20220530/cab6eb634b3044b0a916c91b3552ab61.png
[70 5]: /images/20220530/7e542f2ac4e145bcad99a413531e9713.png
[70 6]: /images/20220530/a6c70f3f10a9462a9f461a5496e5801a.png
[70 7]: /images/20220530/447a6521dfca4fe895754218ba985feb.png
[70 8]: /images/20220530/006bcb346dc14179a0a08e0887086c69.png
[70 9]: /images/20220530/84d539cac9d04550b1ccb44cfdc5c289.png
[70 10]: /images/20220530/06abb8c87f7d48448fca0f97a0576c75.png
[70 11]: /images/20220530/ae3ec11def0145b19f5824b77cad4f04.png
[70 12]: /images/20220530/4da4c26dd69b4f888d7e8eaf8cc9592c.png
[70 13]: /images/20220530/996f393786594a3bb60925da7bd4ae9f.png
[70 14]: /images/20220530/dfa61cad4ac6465fb4f5a6d8df290679.png
[70 15]: /images/20220530/69518c80eebc421d858c125b8b696632.png
[70 16]: /images/20220530/85607333ad234aff98d35466b53784fc.png
[70 17]: /images/20220530/f920ce48399b4087adcd3da3e6aa2bf9.png
[70 18]: /images/20220530/0b37fe854fc44b70b341dbda4d945c7e.png
[70 19]: /images/20220530/c1e089ee884a4078b44bbc43e4535674.png
[70 20]: /images/20220530/04552770cc124c5085e1872d2b4bdd9e.png
[70 21]: /images/20220530/cc5ee5f3c02b49babce7093342354177.png
[70 22]: /images/20220530/e50943922d3748fa96cc0dffeaf6c742.png
[70 23]: /images/20220530/ba297f4d4b3b4f22952151b841e8ec31.png
[70 24]: /images/20220530/95693bcfd7a24ea88cce754f81c6f29a.png
[Image 1]: 
[70 25]: /images/20220530/6ac4cd917cff4d59acf6a5f695cbde36.png
[70 26]: /images/20220530/b5bc7d203b3146349ec731110e7e0ca3.png
[70 27]: /images/20220530/b22cd87a0902434cabb542d1664a8699.png