Java-对象的操作（构造、初始化、封装）、static成员以及代码块

古城微笑少年丶 2024-03-22 23:06 36阅读 0赞

**目录**

一、对象的构造及初始化

1.1 如何初始化对象

1.2 构造方法

1.3 默认初始化

1.4 就地初始化

二、封装

2.1 封装概念

2.2 访问限定符

2.3 封装扩展之包

三、static成员

3.1 再谈学生类

3.2static修饰成员变量

3.3static修饰成员方法

3.4 static成员变量初始化

四、代码块

4.1 代码块概念及分类

4.2 普通代码块

4.3 构造代码块

4.4 静态代码块

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

## 一、对象的构造及初始化 ##

### 1.1 如何初始化对象 ###

> public static void main(String\[\] args) \{
> 
> int a;
> 
> System.out.println(a);
> 
> \}

上述代码在方法内部使用了一个定义但未初始化的局部变量，编译会报错，在使用前要对其进行赋值。

>             public static void main(String[] args) {
>                 Date date=new Date();
>                 date.printDay();
>                 System.out.println("=====");
>                 date.Setday(2023,3,22);
>                 date.printDay();
>             }

![53649aac048d46b6adc3495a41905d05.png][]

上述代码实例化一个对象并利用函数Setday对其赋值，但在赋值前并未报错，这是因为在成员变量未赋初值时，编译器会给类中的成员变量依其类型给一个默认值。每次创建对象后都要调用Setday为对象赋值，那对象该如何初始化呢？

### 1.2 构造方法 ###

**1. 概念**

**构造方法**(也称为构造器)是一个特殊的成员方法，**名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次**。

> public class Date \{
> 
> public int year;
> 
> public int month;
> 
> public int day;
> 
> public void printDay()\{
> 
> System.out.println(this.year+"/"+this.month+"/"+this.day);
> 
> \}
> 
> public Date(int year,int month,int day)\{
> 
> this.year=year;
> 
> this.month=month;
> 
> this.day=day;
> 
> \}
> 
> public static void main(String\[\] args) \{
> 
> Date date=new Date(2023,3,22);
> 
> date.printDay();
> 
> \}
> 
> \}

![05ea176065d143bbb7a97a2ccac4b358.png][]

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

**2. 特性**

1. **名字必须与类名相同**。  
2. **没有返回值类型，设置为void也不行**。  
3. **创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次**(相当于人的出生，每个人只能出生一次)。

4. **构造方法可以重载**

>                public class Date {
>                         public int year;
>                         public int month;
>                         public int day;
>         
>                         public void printDay(){
>                             System.out.println(this.year+"/"+this.month+"/"+this.day);
>                         }
>     
>                         //方法重载
>         
>                         //无参的构造方法(用于对象属性值都相同)
>                         public Date(){
>                             this.year=2023;
>                             this.month=3;
>                             this.day=22;
>                         }
>                         //有参的构造方法（用于对象属性值不相同）
>                         public Date(int year,int month,int day){
>                             this.year=year;
>                             this.month=month;
>                             this.day=day;
>                         }
>     
>                         public static void main(String[] args) {
>                             Date date=new Date();///传不传参都可以
>                             date.printDay();
>                         }
> 
> \}

5.**如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的**。

注意：一旦用户定义构造方法，编译器则不再生成。

> public class Date \{
> 
> public int year;
> 
> public int month;
> 
> public int day;
> 
> public void printDay()\{
> 
> System.out.println(this.year+"/"+this.month+"/"+this.day);
> 
> \}
> 
> public static void main(String\[\] args) \{
> 
> Date date=new Date() ;
> 
> date.printDay();
> 
> \}
> 
> \}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。  
6. 构造方法中，可以通过this调用其他构造方法来简化代码。

>     public class Date {
>         public int year;
>         public int month;
>         public int day;
>         public void printDay(){
>             System.out.println(this.year+"/"+this.month+"/"+this.day);
>         }
>        
>         public Date(int year,int month,int day){
>             this.year=year;
>             this.month=month;
>             this.day=day;
>         }
>         public Date(){
>             this(2023,3,22);
>         }
>         public static void main(String[] args) {
>             Date date=new Date();
>             date.printDay();
>         }

![213b09df8f05474b954a9a0bfca4a3c6.png][]

注意：this(...)必须是构造方法中的第一条语句，不能形成环。

> public Date()\{ //环  
> this(2023,3,22);  
> \}  
> public Date(int year, int month, int day) \{  
> this();  
> \}

7. **绝大多数情况下使用public来修饰，特殊场景下会被private修饰。**

### 1.3 默认初始化 ###

上述中局部变量使用时必须初始化，而成员变量则不用，这是为什么呢？

> public class Date \{
> 
> public int year; //成员变量没有赋初值
> 
> public int month;
> 
> public int day;
> 
>             public Date(int year,int month,int day){
>                 this.year=year;
>                 this.month=month;
>                 this.day=day;
>             }
> 
>             public static void main(String[] args) {
>                 Date date=new Date();
>                 date.printDay();
>             }
> 
> \}

要弄清楚这个问题，要了解new关键字的作用

> Date date=new Date();

程序中只是一条语句，而在JVM层面，则做了很多事：检测对象对应的类是否加载了，如果没有加载则加载；为对象分配内存空间；处理并发安全问题；**初始化所分配的空间**；设置对象头信息；调用构造方法，给对象中各个成员赋值。

<table style="width:400px;"> 
 <tbody> 
  <tr> 
   <td style="width:261px;">数据类型</td> 
   <td style="width:237px;">默认值</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">byte</td> 
   <td style="width:237px;">0</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">char</td> 
   <td style="width:237px;">‘\u0000’</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">short</td> 
   <td style="width:237px;">0</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">int</td> 
   <td style="width:237px;">0</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">long</td> 
   <td style="width:237px;">0L</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">boolean</td> 
   <td style="width:237px;">false</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">float</td> 
   <td style="width:237px;">0.0f</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">double</td> 
   <td style="width:237px;">0.0</td> 
  </tr> 
  <tr> 
   <td style="width:261px;">reference</td> 
   <td style="width:237px;">null&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

### 1.4 就地初始化 ###

在声明成员变量时就赋初值

> public class Date \{  
> public int year = 2023;  
> public int month = 3;  
> public int day = 22;  
> public Date()\{  
> \}  
> public Date(int year, int month, int day) \{  
> \}  
> public static void main(String\[\] args) \{  
> Date d1 = new Date(2022,3,22);  
> Date d2 = new Date();  
> \}  
> \}

![d3337fb6117d4d0089ec0e386dae3621.png][]

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。

## 二、封装 ##

### 2.1 封装概念 ###

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性，封装简单来说就是套壳屏蔽细节。  
例如：一台家用的电脑，有鼠标、显示器、键盘、主机，主机中有主板，提供给用户的就是：开关机、、通过键盘输入、显示器、usb接口等，让用户和计算机进行交互。

![0093f6b0306d48e0b6be7c41e4e47db0.png][]![f11ebc8e48784fdbb71155ff96a26eda.png][]

但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户  
只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此**计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可**。封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互。

### 2.2 访问限定符 ###

Java中主要**通过类和访问权限来实现封装**：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中有四种限定符：private、default、protected和public。

![db1db64d4a1a4890ab0001f32c712214.png][]

public：可以理解为一个人的外貌特征，谁都可以看得到；default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了；private：只有自己知道，其他人都不知道。protected主要是用在继承中；default权限指：什么都不写时的默认权限；访问权限除了可以限定类中成员的可见性，也可以控制类的可见性。

>     public class Person {
>         private String name;//只能在类Person中使用
>         private int age;
>     
>         public Person(){
>             System.out.println("不传参的构造方法");
>         }
>     
>         public Person(String name,int age){
>             this.name=name;
>             this.age=age;
>             System.out.println("传递两个参数的构造方法");
>         }
>         public void Sleep(){
>             System.out.println(name+"正在睡觉");
>         }
>         public void print(){
>             System.out.println("name:"+name+"age:"+age);
>         }
>     
>     }

>     public class Text2 {//同文件（包）下的不同类
>         public static void main(String[] args) {
>             Person person1=new Person("zhangsan",10);
>             System.out.println("name:"+person1.name);//会报错
>         }
>     }

![f5ca0247ff384735994484c46e0ad203.png][]

>     public class Person {
>          String name;//default属性，同文件（包）下都可使用
>          int age;
>     
>         public Person(){
>             System.out.println("不传参的构造方法");
>         }
>     
>         public Person(String name,int age){
>             this.name=name;
>             this.age=age;
>             System.out.println("传递两个参数的构造方法");
>         }
>         public void Sleep(){
>             System.out.println(name+"正在睡觉");
>         }
> 
>         public String getName() {
>             return name;
>         }
>         public void setName(String name) {
>              this.name = name;
>         }
>         public int getAge() {
>             return age;
>         }
>         public void setAge(int age) {
>             this.age = age;
>         }
>     }

>     public class Text2 {同文件（包）下的不同类
>         public static void main(String[] args) {
>             Person person1=new Person("zhangsan",10);
>             System.out.println(person1.getName());//可以通过调用函数获取对象属性值
>             System.out.println(person1.getAge());
>         }
>     }

![cbddd5df806040f9bc3c6b8d15d1e58e.png][]

注意：一般情况下成员变量设置为private，成员方法设置为public

### 2.3 封装扩展之包 ###

**1.包的概念**

**在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包**。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

在Java中也引入了包，**包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式**，比如：一个包中的类不想被其他包中的类使用。**包还有一个作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可**。  
 **2.导入包中的类**

Java 中已经提供了很多现成的类供我们使用。例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类。

> public class Test \{  
> public static void main(String\[\] args) \{  
> java.util.Date date = new java.util.Date();  
> System.out.println(date.getTime());  
> \}
> 
> \}

这种写法比较麻烦一些, 可以使用 **import语句导入包**。

> import java.util.Date;  
> public class Test \{  
> public static void main(String\[\] args) \{  
> Date date = new Date();  
> System.out.println(date.getTime());  
> \}
> 
> \}

如果**需要使用 java.util 中的其他类, 可以使用 import java.util.\***

> import java.util.\*;  
> public class Test \{  
> public static void main(String\[\] args) \{  
> Date date = new Date();  
> System.out.println(date.getTime());  
> \}
> 
> \}

但是我们更**建议显式的指定要导入的类名. 否则还是容易出现冲突**的情况。

> import java.util.\*;  
> import java.sql.\*;  
> public class Test \{  
> public static void main(String\[\] args) \{  
> // util 和 sql 中都有 Date 类, 会出现编译错误  
> Date date = new Date();  
> System.out.println(date.getTime());  
> \}
> 
> \}

在这种情况下就需要使用**完整的类名。**

> import java.util.\*;  
> import java.sql.\*;  
> public class Test \{  
> public static void main(String\[\] args) \{  
> java.util.Date date = new java.util.Date();  
> System.out.println(date.getTime());  
> \}
> 
> \}

可以使用**import static导入包中静态的方法和字段。**

> import static java.lang.Math.\*;  
> public class Test \{  
> public static void main(String\[\] args) \{  
> int x = 30;  
> int y = 40;
> 
> // int result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));  
> int result = sqrt(pow(x, 2) + pow(y, 2));  
> System.out.println(result);  
> \}
> 
> \}

**3.自定义包**

规则：在文件的最上方加上一个 package 语句指定该代码在哪个包中；包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式；包名要和代码路径相匹配.，例如创建com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码；如果一个类没有 package 语句, 则该类被放到一个默认包中。  
创建包的步骤：

1.在 IDEA 中先新建一个包: src ---> New ---> Package  
![32330cd9537846ca84f903f63411daad.png][]

2.在弹出的对话框中输入包的名称。

![5711b568df244ef5954b666ae65b761e.png][]

3.在包中创建类, 包---> New---> class, 之后后输入类名。  
![b103b70ce989402bb026e9e816654f7e.png][]

![8813f2494f1641caae47eaafe6ca6e68.png][]

4.打开文件位置就可以看到磁盘上目录结构已创建

![74c71f19de794dcaa8bd3683a9890c90.png][]

5.在新创建的Text1.java文件最上方有一个package语句

![b682d2f037734592bad95b8a04de8c3d.png][]

**4.常见的包**

1. java.lang:系统常用基础类。

2. java.lang.reflect:java 反射编程包。

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。

6. java.io:I/O编程开发包。

##    三、static成员 ##

### 3.1 再谈学生类 ###

学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成员信息，这些信息是对不同学生进行描述的，例如

> public class Student\{  
> // ...  
> public static void main(String\[\] args) \{  
> Student s1 = new Student("Li leilei", "男", 18, 3.8);  
> Student s2 = new Student("Han MeiMei", "女", 19, 4.0);  
> Student s3 = new Student("Jim", "男", 18, 2.6);  
> \}  
> \}

如果三个同学是一个班的，那么他们上课在同一个教室，那能否给类中再加一个成员变量，来保存同学上课时的教室呢？答案是不行的。

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。**在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的**。

### 3.2static修饰成员变量 ###

**static修饰的成员变量，称为静态成员变量**，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。  
静态成员变量的特性：不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中；既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问；类变量存储在方法区当中；生命周期伴随类的一生。

>             public class Student {
>                 public String name;
>                 public String gender;
>                 public int age;
>                 public double score;
>                 public static String classRoom="bit110";
>                 public Student(String name,String gender,int age,double score){
>                     this.name=name;
>                     this.gender=gender;
>                     this.age=age;
>                     this.score=score;
>                 }
>                 public void print(){
>                     System.out.println(this.name+" "+this.gender+" "+this.age+" "+this.score);
>                 }
>                 public static void main(String[] args) {
>                     //直接通过类名访问
>                     System.out.println(Student.classRoom);
>                     System.out.println("====");
>                     Student s1 = new Student("张三", "男", 18, 3.8);
>                     Student s2 = new Student("李四", "女", 19, 4.0);
>                     Student s3 = new Student("王五", "男", 18, 2.6);
>                     s1.print();
>                     s2.print();
>                     s3.print();
>                     System.out.println("====");
>                     //也可以通过对象访问，三个对象共享classRoom
>                     System.out.println(s1.classRoom);
>                     System.out.println(s2.classRoom);
>                     System.out.println(s3.classRoom);
>         }
>     }

![d7ae33e3f9bc494c93fc5b700d84bfd4.png][]

![449af09d6d91466193e5dda58ac99832.png][]

可以看到，静态成员变量并没有存储到某个具体的对象中。

### 3.3static修饰成员方法 ###

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

>             class Stu {
>                 private String name;
>                 private String gender;
>                 private int age;
>                 private double score;
>                private static String classRoom="bit110";//private修饰只能在自己类中使用
>                 public Stu(String name,String gender,int age,double score){
>                     this.name=name;
>                     this.gender=gender;
>                     this.age=age;
>                     this.score=score;
>                 }
>     
>             }
>                 public class TextStu{
>                     public static void main(String[] args) {
>                             System.out.println(Stu.classRoom);
>                     }
>     
>                  }

编译失败，报错：

![ac6ea0c521a44168ad8cd9926088ce2d.png][]

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

>             //....
>             public static String Getclassroom(){
>                 return classRoom;
>             }
> 
>             public class TextStu{
>                 public static void main(String[] args) {
>                         System.out.println(Stu.Getclassroom());
>                 }
>     
>             }

![80ce874df52246ef8cd2fc8a1455894d.png][]

静态方法特性：不属于某个具体的对象，是类方法；可以通过对象调用，也可以通过类名.静态方法名(...)方式调用；不能在静态方法中访问任何非静态成员变量；静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。

### 3.4 static成员变量初始化 ###

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性，静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

**1.就地初始化**

就地初始化指的是：在定义时直接给出初始值。

> public class Student\{  
> private String name;  
> private String gender;  
> private int age;  
> private double score;  
> private static String classRoom = "bit110";  
> // ...  
> \}

**2.静态代码块初始化**

看后文---

## **四、代码块** ##

###  **4.1 代码块概念及分类** ###

**使用 \{\} 定义的一段代码称为代码块**。根据代码块定义的位置以及关键字，又可分为以下四种：普通代码块、构造块、静态块和同步代码块。

###  **4.2 普通代码块** ###

普通代码块：定义在方法中的代码块。

> public class Main\{  
> public static void main(String\[\] args) \{  
> \{ //直接使用\{\}定义，普通方法块  
> int x = 10 ;  
> System.out.println("x1 = " +x);  
> \}
> 
> int x = 100 ;  
> System.out.println("x2 = " +x);  
> \}
> 
> \}

![6acf08bc01fd40febce17cf566779f71.png][]

###  **4.3 构造代码块** ###

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

>     class Student {
>         //成员变量
>         private String name;
>         private String gender;
>         private int age;
>         private double score;
>         public  Studenet(){
>             System.out.println("Student()");
>         }
>             //实例代码块
>         {
>             this.name="zhangsan";
>             this.age=15;
>             this.gender="nan";
>             System.out.println("实例");
>         }
>         public void show(){
>             System.out.println(this.name+" "+this.age+" "+this.gender);
>         }
>     
>     }
>     public class fangfakuai {
>         public static void main(String[] args) {
>             Student stu1=new Student();
>             stu1.show();
>         }

![eea78bbe69fd441e9d10dd5d9fc76763.png][]

![d0fdd46ef12f4548a611a68766f57e7f.png][]

###  **4.4 静态代码块** ###

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

>             class Student {
>                 //成员变量
>                 private String name;
>                 private String gender;
>                 private int age;
>                 private double score;
>                 private static String classRoom;
>     
>                 public  Student(){
>                     System.out.println("Student()");
>                 }
>                 //实例代码块
>                 {
>                     this.name="zhangsan";
>                     this.age=15;
>                     this.gender="nan";
>                     System.out.println("实例代码块");
>                 }
>                     //静态代码块
>                     static {
>                     classRoom="bit110";
>                     System.out.println("静态代码块");
>                     System.out.println("======");
>                 }
>                 public void show(){
>                     System.out.println(this.name+" "+this.age+" "+this.gender);
>                 }
>     
>             }
>             public class TextStudent {
>                 public static void main(String[] args) {
>                     Student stu1=new Student();
>                     Student stu2=new Student();
>                 }

![da506ce6944647c2b6dfad826e93b65d.png][]

![1e1546d9c09d49a8ada11cabd776bf1b.png][]

注意：静态代码块不管生成多少个对象，其只会执行一次；静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的；如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行；实例代码块只有在创建对象时才会执行。

[53649aac048d46b6adc3495a41905d05.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c2577d79ca884e6b9435856a85d39893.png
[05ea176065d143bbb7a97a2ccac4b358.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8ac7056d2a0242d1839b110e7007016c.png
[213b09df8f05474b954a9a0bfca4a3c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e4c1ab6029fd4fdbb825c4d75932542b.png
[d3337fb6117d4d0089ec0e386dae3621.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7cbd7b95e18647909b50f270b8465e37.png
[0093f6b0306d48e0b6be7c41e4e47db0.png]: https://img-blog.csdnimg.cn/0093f6b0306d48e0b6be7c41e4e47db0.png
[f11ebc8e48784fdbb71155ff96a26eda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/01779e7b86154970a7d19339e227179f.png
[db1db64d4a1a4890ab0001f32c712214.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/be4bc40c3e45482c9d343434b9ae7e4e.png
[f5ca0247ff384735994484c46e0ad203.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/aed5ad6ff47f4d6e96298ab3d12b53ae.png
[cbddd5df806040f9bc3c6b8d15d1e58e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/186c435196f04c4ebc5d6e3f0a8d03ea.png
[32330cd9537846ca84f903f63411daad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c967dafb2b0d44e7ada7f886b824be17.png
[5711b568df244ef5954b666ae65b761e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0c710ee9f01848d4b5a5b0fbc872d855.png
[b103b70ce989402bb026e9e816654f7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/eeb2ef7d54da418599016231c9e4d7b4.png
[8813f2494f1641caae47eaafe6ca6e68.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c26adc760c7a4c7e821871d20a51f6c8.png
[74c71f19de794dcaa8bd3683a9890c90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/397429bae9384b73a4b1e9a2b9e10ab0.png
[b682d2f037734592bad95b8a04de8c3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bcd1e062c6134dd7a8b8bdeadd15b09d.png
[d7ae33e3f9bc494c93fc5b700d84bfd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9a827c6929db498ba112aaed5dea9538.png
[449af09d6d91466193e5dda58ac99832.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e92f6be849f2446a987269d7307ff903.png
[ac6ea0c521a44168ad8cd9926088ce2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/16a9ba4f883846a5966da8508ba463f0.png
[80ce874df52246ef8cd2fc8a1455894d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/587394a90eea42e8b8a12ab03529c2ef.png
[6acf08bc01fd40febce17cf566779f71.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4499a6c2a983451a90d62012f58183c9.png
[eea78bbe69fd441e9d10dd5d9fc76763.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ea44432b36d2499b94fe0cfa3f80eb76.png
[d0fdd46ef12f4548a611a68766f57e7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b57b5e512fe942cfa41bf9b77b7d1a0f.png
[da506ce6944647c2b6dfad826e93b65d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/da220b9005f34cc881c158ab39449260.png
[1e1546d9c09d49a8ada11cabd776bf1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2b852cc0adfc44189b051b61f2782cb5.png