Java 面向对象 | 详细知识图谱式讲解

短命女 2024-04-22 19:14 72阅读 0赞

![在这里插入图片描述][acb8a7e0bf334001af9f95d515c4f452.gif_pic_center]

> [?wei\_shuo的个人主页][wei_shuo]
> 
> ?[wei\_shuo的学习社区][wei_shuo 1]
> 
> ?Hello World ！

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

### ☢Java入门 ###

>  *  基础知识：了解 Java 基本语法、面向对象编程（OOP）概念、流程控制语句、数据类型、方法等基础知识。可以通过 Java 编程入门教程、Java 编程思想等书籍进行学习。
>  *  面向对象编程：深入学习 OOP 概念，包括封装、继承、多态、接口等。掌握设计模式、反射机制等高级特性。可以参考《Effective Java》等书籍进行学习。
>  *  Java 核心类库：熟练掌握 Java 核心类库，包括集合框架、IO、并发、网络编程等。可以参考《Java 核心技术》等书籍进行学习。
>  *  Web 开发：学习 Java Web 开发相关知识，包括 Servlet、JSP、MVC 模式、Spring 框架、Hibernate 等。可以参考《Spring 实战》、《Hibernate 实战》等书籍进行学习。
>  *  数据库编程：学习使用 Java 连接数据库、操作数据库等知识。可以学习 MySQL、Oracle、MongoDB 等常用数据库的使用。
>  *  其他领域：学习 Android 开发、Java 大数据开发、Java 游戏开发等其他领域的知识

### ☢Java面向对象 ###

>  *  面向过程POP(`C语言`)
> 
> 面向过程是`自上而下`的设计语言，先定好框架，再增砖添瓦。通俗点，就是先定好main()函数，然后再逐步实现mian()函数中所要用到的其他方法
> 
>  *  面向对象OOP(`c++`，`c#`，`java`，`delphi`)
> 
> 面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的`对象`，其基本思想是`一切皆对象`，是一种`自下而上`的设计语言，先设计组件，再完成拼装

### ☢构造方法 ###

> 构造方法是一种特殊的方法
> 
> 作用：完成对象数据的初始化
> 
> 格式：
> 
>     public class 类名{
>          
>     	修饰符 类名(参数){
>          
>     	……
>     	}
>     }

>  *  无参构造方法
> 
>     //无参构造方法
>         public Student() {
>          
>             System.out.println("无参构造方法");
>         }
> 
>  *  带参构造方法
> 
>     //带参构造方法
>     public Student(String name, int age) {
>          
>         this.name = name;
>         this.age = age;
>     }
> 
>  *  构造方法调用
> 
>     //创建对象，实例化对象
>     Student student = new Student();    //调用无参构造方法
>     
>     System.out.println("===================");
>     
>     final Student student2 = new Student("wei",18); //调用带参构造方法

>  *  创建Student类
> 
>     package itiheima_02;
>     
>     public class Student {
>          
>         //定义成员变量
>         private String name;
>         private int age;
>     
>         //定义成员方法
>         public void show() {
>          
>             System.out.println("name:" + name + "," + "age:" + age);
>         }
>     
>         //无参构造方法
>         public Student() {
>          
>             System.out.println("无参构造方法");
>         }
>     
>         //带参构造方法
>         public Student(String name, int age) {
>          
>             this.name = name;
>             this.age = age;
>         }
>     }
> 
>  *  创建StudentDemo测试类
> 
>     package itiheima_02;
>     
>     public class StudentDemo {
>          
>         public static void main(String[] args) {
>          
>             //创建对象，实例化对象
>             Student student = new Student();    //调用无参构造方法
>             student.show(); //name、age未赋值所以输出结果为空  name:null,age:0
>     
>             System.out.println("===================");
>     
>             final Student student2 = new Student("wei",18); //调用带参构造方法
>             student2.show();    //name:wei,age:18
>         }
>     }

#### ?成员方法和构造方法的区别 ####

> 构造方法：
> 
>  *  没有返回值类型，没有return，方法名和类名相同
>  *  如果没有写构造方法，系统会自动添加一个无参构造方法
> 
> 成员方法：
> 
>  *  有返回值类型，若有返回值类型为空void,则可以不写return，成员方法名和类名不能相同
>  *  系统不会自动添加成员方法
> 
> 总结：成员方法有返回值，构造方法无返回值

package itiheima_05;
    
    public class TEST {
        
        int age = 18;
        String name = "WEi_SHUO";
    
        //无参构造方法，没有写构造方法，系统会自动添加一个无参构造方法
        public TEST() {
        
        }
    
        //带参构造方法
        public TEST(int age, String name) {
        
            this.age = age;
            this.name = name;
        }
    
        //成员方法
        public void show(){
        
            //局部变量（成员方法中的变量）
            int age = 18;
            System.out.println(age);
        }
    }

### ☢类/方法 ###

#### ?类 ####

> 类的组成：属性和行为
> 
> 属性：类中通过成员变量体现
> 
> 行为：类中通过成员方法体现

> Java中的类是通过class关键字来定义
> 
>     [修饰符] class 类名 [extends 父类名] [implements 接口名]{
>          
>     
>     // 类体，包括类的成员变量和成员方法
>     
>     }

#### ?方法 ####

> 有参和无参
> 
>  *  无参方法
> 
>     public static void wucan(){
>           
>             System.out.println("无参方法");
>     }
> 
>  *  带参方法
> 
>     public static void sum(int a,int b){
>           
>             System.out.println("两数相加结果"+a+b); 
>     }
> 
> 有无返回值
> 
>  *  有返回值
> 
>     public static int sum(int a,int b){
>          
>             return a+b;
>     }
> 
>  *  无返回值
> 
>     public static void sum(int a,int b){
>          
>            System.out.println("无返回值"); 
>     }

#### ?对象 ####

> 对象是类的一个实例，通过new这个关键字使用构造方法创建当前类的对象
> 
> 格式：类名 对象名 = new 类名();
> 
>     Phone p = new Phone();

> 对象的使用
> 
> 使用成员变量：
> 
>  *  格式：对象名.变量名
>  *  p.brand
> 
> 使用成员方法
> 
>  *  格式：对象名.方法名
>  *  p.call()

> 创建对象步骤：
> 
>  *  **声明**：声明一个对象，包括对象名称和对象类型
>  *  **实例化**：使用关键字 new 来创建一个对象
>  *  **初始化**：使用 new 创建对象时，会调用构造方法初始化对象

>  *  创建Phone类
> 
>     package itiheima_01;
>     
>     public class Phone {
>          
>         //成员变量
>         String brand;
>         int price;
>     
>         //成员方法
>         public void call(){
>          
>             System.out.println("打电话");
>         }
>     
>         public void SendMessage(){
>          
>             System.out.println("发短信");
>         }
>     }
> 
>  *  创建PhoneDemo测试类
> 
>     package itiheima_01;
>     
>     public class PhoneDemo {
>          
>         public static void main(String[] args) {
>          
>             Phone p = new Phone();
>     		System.out.println(p);  //itiheima_01.Phone@1b6d3586  内存地址
>             
>             //成员变量赋值
>             p.brand="小米";
>             p.price=1999;
>     
>             //输出成员变量
>             System.out.println(p.brand);
>             System.out.println(p.price);
>             /*
>             执行结果：
>             小米
>             1999
>             */
>     
>             //调用成员方法
>             p.call();
>             p.SendMessage();
>             /*
>             执行结果：
>             打电话
>             发短信
>             */
>     
>         }
>     }

### ☢变量 ###

#### ?成员变量/局部变量/成员方法 ####

![在这里插入图片描述][7aee1e04c10a4f629b34f7be6199cfa1.png_pic_center]

>  *  成员变量（全局变量）：类中方法外的变量
>  *  局部变量：成员方法中的变量
>  *  成员方法：类中定义的方法
> 
>     //特殊的成员方法：main():
>     public static void main(String[] args){
>          
>     			//特定的功能
>     }
>     
>     //一般的成员方法：
>     public 返回值类型 方法名(形式参数列表){
>          
>             //方法体;(特定功能的代码)
>             return 返回值;
>     }

#### ?静态变量/实例变量 ####

![在这里插入图片描述][46a6a4dd508e44519512857f6ee311cb.png_pic_center]

>  *  静态变量
>     
>     静态变量用 static字符修饰，随着类的加载而加载，静态变量存放在方法池中的静态区，可以直接通过"类名.变量名直接"调用，也可以通过类的对象调用
>  *  实例变量
>     
>     实例变量相当于该类的属性，需要 "new对象 "才能被调用。而且该变量不常驻内存，当这个类不再被使用时会java回收机制所释放
>  *  区别
>     
>      *  存储区域不同：静态变量存储在静态存储区域，实例变量存储在堆中，会被释放
>      *  生命周期不同：静态变量在类启动时就分配指定内存；实例变量在被对象调用后才分配内存，调用结束时内存释放
>      *  静态变量与类相关，实例变量与对象相关

>  *  实例变量在被对象调用后才分配内存，调用结束时内存释放；所以random两次调用后任然为3
>  *  静态变量在类启动时就分配指定内存；所以第二次调用之后为4
> 
>     public class TEST {
>          
>             private static int staticInt = 2;//静态变量
>             private int random = 2;//实例变量
>     
>             public TEST() {
>          		//TEST无参构造方法
>                 staticInt++;
>                 random++;
>                 System.out.println("staticInt = "+staticInt+"  random = "+random);
>             }
>     
>             public static void main(String[] args) {
>          	//main方法：特殊的成员方法
>                 //定义test变量，通过new关键字创建TEST对象，进而调用TEST无参构造方法
>                 TEST test = new TEST();
>                 TEST test2 = new TEST();
>             }
>     
>     }
>     
>     /*
>     输出结果：
>     staticInt = 3  random = 3
>     staticInt = 4  random = 3
>     */

>  *  静态代码块（`静态代码块>构造代码块>构造函数>普通代码块`）
>     
>     静态代码块写在类里面的时候，优先于类的加载、执行，且只会被加载一次
> 
>     public class Car {
>          
>         static String color;
>         // 下面是一个静态代码块
>         static {
>          
>             color = "red";
>             System.out.println("这辆车的颜色是" + color);
>         }
>     }

### ☢封装 ###

> 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过成员变量private，提供对应的`get`/`set`方法
> 
>  *  通过方法来控制成员变量的操作，提高了代码的安全性
>  *  代码用方法封装，提高代码的复用性
> 
> 语法格式：
> 
>     public class Person {
>          
>         private String name;
>         private int age;
>     }

### ☢继承 ###

![在这里插入图片描述][90ed86c9220846689e2bda5390fea5de.png_pic_center]

> 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
> 
>  *  提高代码复用性和维护性
>  *  子类和父类产生关系，耦合性增强父类变化子类也需要变化

> 继承格式：
> 
>     public class 子类名 extend 父类名{}
> 
> 继承中子类特点
> 
>  *  子类可以有父类的内容
>  *  子类也可以有特有的内容

### ☢多态 ###

> 同一个对象，在不同时刻表现出来的不同形态
> 
> 多态的前提和体现
> 
>  *  继承/实现关系
>  *  方法重写
>  *  父类引用指向子类对象

> 多态访问中成员访问的特点
> 
>  *  成员变量：编译看左边，执行看左边
>  *  成员方法：编译看左边，执行看右边
>  *  原因：成员方法有重写，成员变量没有
> 
> Animal类
> 
>     package itiheima_02;
>     
>     public class Animal {
>          
>     
>         public int age =40;
>     
>         public void eat(){
>          
>             System.out.println("动物吃东西");
>         }
>     }
> 
> Cat类
> 
>     package itiheima_02;
>     
>     public class Cat extends Animal{
>          
>     
>         public int age=20;
>         public int weight=10;
>     
>         @Override
>         public void eat() {
>          
>             System.out.println("猫吃鱼");
>         }
>     
>         public void playGame(){
>          
>             System.out.println("猫捉迷藏");
>         }
>     }
> 
> AnimalDemo测试类
> 
>     package itiheima_02;
>     
>     
>         /*
>         多态前提和体现
>         继承/实现关系
>         方法重写
>         父类引用指向子类对象
>         */
>     
>     public class AnimalDemo {
>          
>         public static void main(String[] args) {
>          
>             //父类引用指向子类对象——多态
>     
>             Animal animal = new Cat();
>     
>             //多态方式访问成员变量：编译看左边，运行看左边
>             System.out.println(animal.age);
>     
>             //多态方式访问成员方法：编译看左边，运行看右边
>             animal.eat();
>     
>     
>         }
>     }

#### ?多态中的转型 ####

>  *  向上转型
>     
>     从子到父
>     
>     父类引用指向子类对象
>  *  向下转型
>     
>     从父到子
>     
>     父类引用转为子类对象
> 
> 向下转型解决了多态的弊端：不能访问`子类的特有功能`

>  *  Animal类
> 
>     package itiheima_02;
>     
>     public class Animal {
>          
>     
>         public int age =40;
>     
>         public void eat(){
>          
>             System.out.println("动物吃东西");
>         }
>     }
> 
>  *  Cat类
> 
>     package itiheima_02;
>     
>     public class Cat extends Animal{
>          
>     
>         @Override
>         public void eat() {
>          
>             System.out.println("猫吃鱼");
>         }
>     
>         public void playGame(){
>          
>             System.out.println("猫捉迷藏");
>         }
>     }
> 
>  *  AnimalDemo测试类
> 
>     package itiheima_02;
>     
>     
>     /*
>     - 向上转型
>       从子到父
>       父类引用指向子类对象
>     
>     - 向下转型
>       从父到子
>       父类引用转为子类对象
>     */
>     
>     public class AnimalDemo {
>          
>         public static void main(String[] args) {
>          
>             /*
>             多态
>             向上转型:
>             从子到父
>             父类引用指向子类对象
>             */
>             Animal animal = new Cat();  //向上转型
>             //多态访问成员方法：编译看左边，执行看右边
>             animal.eat();   //猫吃鱼
>     //        animal.playGame();    Error,因为编译看左边，左边Animal没有playGame方法
>     
>             //使用Cat中playGame方法有两种方法：
>     
>             //方式一：
>             //创建Cat类对象
>             Cat cat = new Cat();
>             cat.eat();  //猫吃鱼
>             cat.playGame(); //猫捉迷藏
>     
>     
>             //方式二：
>             /*
>             多态
>             向下转型
>             从父到子
>             父类引用转为子类对象
>             */
>             Cat cat1 = (Cat) animal;
>             cat1.eat();     //猫吃鱼
>             cat1.playGame();    //猫捉迷藏
>     
>             //向下转型解决了多态的弊端：不能访问子类的特有功能
>     
>         }
>     }

### ☢String概述 ###

> String构造方法
> 
> <table> 
>  <thead> 
>   <tr> 
>    <th>方法名</th> 
>    <th>说明</th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>public String()</td> 
>    <td>创建一个空白字符串对象，不会有任何内容</td> 
>   </tr> 
>   <tr> 
>    <td>public String(char[] chs)</td> 
>    <td>根据字符数组的内容，来创建字符串对象</td> 
>   </tr> 
>   <tr> 
>    <td>public String(byte[] bys)</td> 
>    <td>根据字节数组的内容，来创建字符串对象</td> 
>   </tr> 
>   <tr> 
>    <td>String s = “abc”;</td> 
>    <td>直接赋值的方式创建字符创对象，内容就是abc</td> 
>   </tr> 
>  </tbody> 
> </table>

#### ?StringBulider概述 ####

> StringBulider构造方法
> 
> <table> 
>  <thead> 
>   <tr> 
>    <th>方法名</th> 
>    <th>说明</th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>public StringBulider()</td> 
>    <td>创建一个空白可变字符串对象，不含有任何内容</td> 
>   </tr> 
>   <tr> 
>    <td>public StringBulider(String str)</td> 
>    <td>根据字符串的内容，来创建可变字符串对象</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> StringBulider添加/反转方法
> 
> <table> 
>  <thead> 
>   <tr> 
>    <th>方法名</th> 
>    <th>说明</th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>public StringBulider append(任意类型)</td> 
>    <td>添加数据，并返回对象本省</td> 
>   </tr> 
>   <tr> 
>    <td>public StringBulider reverse()</td> 
>    <td>返回相反的字符序列</td> 
>   </tr> 
>  </tbody> 
> </table>

#### ?String和StringBulider相互转换 ####

>  *  StringBulider转换String
>     
>      *  通过toString()可以实现
> 
>     public string toString();
> 
>     //StringBulider转换String
>             StringBuilder stringBuilder = new StringBuilder();
>             stringBuilder.append("hello");
>             String s = stringBuilder.toString();
>             System.out.println(s);  //hello
> 
>  *  String转换StringBulider
>     
>      *  通过构造方法可以实现
> 
>     public StringBulider(String s);
> 
>     //String转换StringBulider
>             String s = "hello";
>             StringBuilder stringBuilder = new StringBuilder(s);
>             System.out.println(stringBuilder);      //hello

### 集合框架 ###

![在这里插入图片描述][7c3154a09be9406ca9ceaa6f57fe2201.png_pic_center]

![在这里插入图片描述][a09e51e9c4f94697b0703244c8f543d6.png_pic_center]

> 集合：
> 
>  *  Collection集合：单列集合、类似数组，每个元素只包含一个值
>     
>      *  List集合：可重复集合
>         
>          *  ArrayList集合
>          *  LinkedList集合
>      *  Set集合：不可重复集合
>         
>          *  HashSet集合
>          *  TreeSet集合
>  *  Map集合：双列集合、类似二维数组，每个元素包含键值对
>     
>      *  HashMap集合

#### ?Collection集合 ####

> 概述：
> 
>  *  单例集合的顶层接口，表示一组对象，这些对象成为Collection的元素
>  *  JDK不提供接口的任何直接实现，提供更具体的子接口`Set`/`List`实现
> 
> 创建Collection集合对象
> 
>  *  多态方式
>  *  具体实现类ArrayList

#### ?ArrayList集合 ####

>  *  ArrayList集合构造方法和添加方法
> 
> <table> 
>  <thead> 
>   <tr> 
>    <th>方法名</th> 
>    <th>说明</th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>public ArrayList()</td> 
>    <td>创建一个空的集合对象</td> 
>   </tr> 
>   <tr> 
>    <td>public boolean add(E e)</td> 
>    <td>将指定的元素追加到此集合末尾</td> 
>   </tr> 
>   <tr> 
>    <td>public boolean add(int index,E element)</td> 
>    <td>在此集合的指定位置插入指定元素</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
>     ArrayList<String> arrayList = new ArrayList<>();
>             arrayList.add("hello");
>             arrayList.add("world");
>             arrayList.add(1,"java");
>             System.out.println(arrayList);      //[hello, java, world]
> 
>  *  ArrayList集合常用方法
> 
> <table> 
>  <thead> 
>   <tr> 
>    <th>方法名</th> 
>    <th>说明</th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>public boolean remove(Object)</td> 
>    <td>删除指定元素，返回删除是否成功</td> 
>   </tr> 
>   <tr> 
>    <td>public E remove(int index)</td> 
>    <td>删除指定索引的元素，返回被删除的元素</td> 
>   </tr> 
>   <tr> 
>    <td>public E set(int index,E element)</td> 
>    <td>修改指定索引处的元素，放回被修改的元素</td> 
>   </tr> 
>   <tr> 
>    <td>public E get(int index)</td> 
>    <td>放回指定索引处的元素</td> 
>   </tr> 
>   <tr> 
>    <td>public int size()</td> 
>    <td>放回集合中的元素的个数</td> 
>   </tr> 
>  </tbody> 
> </table>

### ☢权限修饰符 ###

![在这里插入图片描述][5119f6b5c8e04416badefe9fd998719a.png_pic_center]

> 作用：用于控制被修饰变量，方法，类的可见范围
> 
> 访问权限修饰符: `由小到大—private –default—protected—public`

#### ?private(私有) ####

>  *  private关键字是`权限修饰符`，修饰`成员变量`、`成员方法`
>  *  保护成员变量、成员方法不被别的类使用，被private修饰的成员变量、成员方法只能在`本类`中访问

> private关键字修饰的成员变量，如果被其它类使用，需要响应的操作
> 
>  *  提供"`get变量名()`"方法，用于获取成员变量的值，方法用`public`修饰
>  *  提供"`set变量名(参数)`"方法，用于获取成员变量的值，方法用`public`修饰

>  *  Student类
> 
>     //Student类
>     public class Student {
>          
>         //成员变量：类中，方法外
>         String name;
>         private int age;
>     
>         //提供get、set方法设置、获取值
>     
>     
>         public int getAge() {
>          
>             return age;
>         }
>     
>         public void setAge(int age) {
>          
>             this.age = age;
>         }
>     
>         //成员方法
>         public void show() {
>          
>             System.out.println(name + "," + age);
>         }
>     }
> 
>  *  StudentDemo测试类
> 
>     public class StudentDemo {
>          
>         public static void main(String[] args) {
>          
>             //创建对象
>             Student s = new Student();
>     
>             //给成员变量赋值
>             s.name="wei_shuo";
>             s.setAge(18);	//使用setAge设置值、getAge可获取值
>     
>             //调用show方法
>             s.show();
>         }
>     }

#### ?default(默认) ####

> 背景：接口在Java中定义之初，有一个缺点，如果定义了一个接口，接口中又定义了N个方法，那么某个具体的类在实现该接口时，需要实现接口中的`所有方法`，不管是否需要用到接口中的方法。如果接口中的某个方法被default关键字修饰了，那么具体的实现类中可以不用实现方法
> 
>  *  default关键字大部分都应用于接口
>  *  通过default关键字定义的方法，集成该接口的方法不需要去实现该方法

>  *  Person接口
> 
>     public interface Person {
>          
>         default String getName(){
>          
>             return "hello world";
>         }
>     }
> 
>  *  Student实现类（实现该接口的类不需要去实现该方法）
> 
>     class Student implements Person {
>          
>         //可以不用实现show()方法
>     }
> 
>  *  main方法
> 
>     public static void main(String[] args) {
>          
>             Student student = new Student();
>             System.out.println(student.getName());
>         }

#### ?protected(保护) ####

> Java 中的 `protected` 是一种访问修饰符，用于限制对类成员的访问。被声明为 `protected` 的类成员可以被其同一包中的其他类访问，以及该类的子类中访问。
> 
> 具体来说，如果一个类成员被声明为 `protected`，那么该成员可以在以下情况下被访问：
> 
>  *  从同一包中的其他类访问该成员。
>  *  从子类中访问该成员。
> 
> 在其他情况下，无法直接访问 `protected` 成员。需要通过子类来访问该成员，或者通过该类的公共方法来访问。
> 
> 需要注意的是，`protected` 成员与 `private` 成员的区别在于，`protected` 成员可以被该类的子类访问，而 `private` 成员则不能。而与 `public` 成员相比，`protected` 成员的访问权限更加受限，只能在同一包中或子类中访问

#### ?public(公开) ####

> 在 Java 中，`public` 是一种访问修饰符，用于声明一个类、方法或变量可以被任何类访问。被声明为 `public` 的类、方法或变量可以在任何地方被访问，包括其他包中的类。
> 
> 具体来说，如果一个类、方法或变量被声明为 `public`，那么它可以在以下情况下被访问：
> 
>  *  从任何其他类中访问该类、方法或变量。
>  *  从该类所在的包中的任何其他类访问该类、方法或变量。
>  *  从任何其他包中的类访问该类、方法或变量，但需要通过完全限定的类名（包括包名和类名）来访问。
> 
> 需要注意的是，`public` 成员的访问权限最大，但是为了保证程序的封装性和安全性，不建议将所有类、方法或变量都声明为 `public`。通常情况下，只有那些需要在不同的包或类之间共享的元素才会被声明为 `public`。而对于仅在本类或包中使用的元素，应该将其声明为 `private` 或 `protected`

### ☢状态修饰符 ###

#### ?final ####

> final：final关键字是最终的意思，可修饰成员变量，成员方法，类
> 
> 特点：
> 
>  *  修饰方法：表名改方法是最终方法，不能被重写
>  *  修饰变量：表名该变量是常量，不能被再次赋值
>  *  修饰类：表名该类是最终类，不能被继承

#### ?static ####

### ☢抽象修饰符 ###

#### ?abstract ####

>  *  抽象类和抽象方法必须使用abstract关键字修饰
> 
>     //抽象类
>     public abstract class 类名{
>          };
>     //抽象方法
>     public abstract void eat();
> 
>  *  抽象类不一定有抽象方法，有抽象方法一定是抽象类
>  *  抽象类实例化：参照多态方式，通过子类对象实例化（抽象类多态）
>  *  抽象类的子类：要么重写抽象类中所有抽象方法；要么子类是抽象类

### ☢关键字 ###

#### ?static ####

> static关键字是静态的意思，可以修饰成员方法，成员变量
> 
> 特点：
> 
>  *  被static修饰会被类的所有`对象共享`，可以使用`类名`调用，也可以使用`对象名`访问

>  *  Student类
> 
>     //Student类
>     public class Student {
>          
>         //成员变量
>         public String name;
>         public int age;
>         //被所有对象共享的成员使用static修饰
>         public static String university;
>     
>     
>         //成员方法
>         public void show() {
>          
>             System.out.println(name + "," + age + "," + university);
>         }
>     }
> 
>  *  StaticDemo测试类
> 
>     package itiheima_03;
>     
>     
>     public class StaticDemo {
>          
>         public static void main(String[] args) {
>          
>             //static修饰的成员变量可以通过对象名访问，也可以通过类名访问
>             Student.university = "加里敦大学";
>     
>             //创建学生类对象
>             Student s1 = new Student();
>             //Student类中name、age、university使用public修饰所以可以使用  对象.成员变量名  访问赋值
>             s1.name="yiyi";
>             s1.age=18;
>             s1.university="加里敦大学";    //对象名访问可行
>             s1.show();
>     
>             Student s2 = new Student();
>             s2.name="erer";
>             s2.age=20;
>            	s2.university="加里敦大学";      //对象名访问可行
>             s2.show();
>     
>         }
>     }
>     
>     /*
>     输出结果：
>     yiyi,18,加里敦大学
>     erer,20,加里敦大学
>     */

> 静态变量: 随着类加载被分配在方法区的静态区域,内存中只有一个,被类的所有实例共享
> 
> 非静态变量: 被实例化之后才分配内存,分配在堆内存中的对象空间里面

> static方法调用非静态变量的问题？
> 
> JVM加载顺序：
> 
>  *  静态块(静态变量)——>成员变量——>构造方法——>静态方法
>     
>     静态代码块(只加载一次)
>     
>     构造方法(创建一个实例就加载一次)
>     
>     静态方法需要调用才会执行
>  *  本质： JVM加载顺序约定的，加载 static 方法的时候非静态方法还没初始化
>  *  static方法是静态方法，属于类的方法；非static方法，属于对象的方法
>  *  非static方法是要与对象关联在一起的，必须在创建出一个对象后，才可以通过这个对象调用非static方法；而static方法可以直接通过类名来调用，不需要创建对象
>  *  一个static方法被调用时，还可能没有创建任何实例对象，此时如果从static内部发出对非static方法的调用，非static方法是无法关联到对象的
> 
>     package itiheima_03;
>     
>     public class Student {
>          
>         static String name;	//静态name成员变量
>         int age; //非静态age成员变量
>     
>         public static void show1(){
>          	//静态show1方法
>             System.out.println(name);
>             //System.out.println(age); //报错，静态方法无法调用非静态变量
>         }
>     
>         public void show2(){
>           //静态show2方法
>             System.out.println(name+","+age);
>         }
>     }

#### ?void ####

> void是一种数据类型，Java的底层代码中，对应一个void类
> 
> 作用：说明该方法`无返回值`

#### ?main ####

> main函数也叫作主函数，主函数是一个作为程序入口的静态函数，可以被`JVM`识别并自动加载

> 格式：
> 
>     public static void main(String[] args){}
> 
> main：众多编程语言的通用名称，用于表示主方法的入口。main虽然不是关键字，但是会被JVM识别
> 
> String\[\] args 作用：接收键盘录入的数据，表示一个字符串数组
> 
>  *  String\[\]表示的是`字符串类型的数组`
>  *  args表示的是`传入的参数名`
>  *  主方法main(String\[\] args)可以接收一个`字符串`类型的数组，数组名字为`args`

#### ?class ####

> class 关键字用于创建一个类。Java运行的每一行代码都必须在一个类中。类应始终以大写首字母开头，并且Java文件的名称必须与类名称匹配。
> 
> Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建

#### ?this ####

![在这里插入图片描述][9603590fe3bf4c10a12c974c242a490e.png_pic_center]

> this修饰的变量用于指代成员变量
> 
>  *  方法的形参如果与成员变量同名
>     
>      *  this关键字修饰的指的是成员变量，不带this关键字修饰的是方法形参
>  *  方法的形参与成员变量不同名
>     
>      *  不带this修饰的变量指的是成员变量
>  *  this关键字：避免局部变量与成员变量同名，导致局部变量隐藏
> 
> this：代表所在类的对象引用(方法被哪个对象引用，this就代表哪个对象)

#### ?super ####

> super：代表父类存储空间的标识（父类对象应用）
> 
> this：代表本类对象引用

>  *  FU类
> 
>     public class FU {
>          
>         int age =40;
>     }
> 
>  *  ZI类
> 
>     public class ZI extends FU{
>          
>         int age = 20;
>     
>         public void show(){
>          
>             int age = 30;
>             //调用局部变量age
>             System.out.println(age);
>             //调用成员变量age
>             System.out.println(this.age);
>             //调用父类变量age
>             System.out.println(super.age);
>         }
>     }
> 
>  *  Demo测试类
> 
>     public class Demo {
>          
>         public static void main(String[] args) {
>          
>             ZI zi = new ZI();
>             zi.show();
>         }
>     }
>      		/*
>             输出结果：
>             30
>             20
>             40
>             */

#### ?extend ####

> 在 Java 中，`extends` 是一种关键字，用于表示一个类继承自另一个类。子类可以继承父类的属性和方法，并可以添加自己的属性和方法。
> 
> 下面是一个简单的 Java 代码示例，演示了如何使用 `extends` 关键字创建一个子类，并继承父类的属性和方法：
> 
>     public class Animal {
>          
>         protected String name;
>         
>         public Animal(String name) {
>          
>             this.name = name;
>         }
>         
>         public void makeSound() {
>          
>             System.out.println("The animal makes a sound");
>         }
>     }
>     
>     public class Dog extends Animal {
>          
>         public Dog(String name) {
>          
>             super(name);
>         }
>         
>         @Override
>         public void makeSound() {
>          
>             System.out.println("The dog barks");
>         }
>     }
>     
>     public class Main {
>          
>         public static void main(String[] args) {
>          
>             Animal animal = new Animal("Animal");
>             animal.makeSound(); // 输出 "The animal makes a sound"
>             
>             Dog dog = new Dog("Fido");
>             dog.makeSound(); // 输出 "The dog barks"
>             System.out.println(dog.name); // 输出 "Fido"
>         }
>     }
> 
> 在上面的例子中，`Animal` 类是一个基类，`Dog` 类是一个继承自 `Animal` 类的子类。`Dog` 类继承了 `Animal` 类的 `name` 属性和 `makeSound()` 方法，并且通过 `@Override` 注解覆盖了 `makeSound()` 方法，使其输出狗叫的声音。在 `Main` 类中，我们创建了一个 `Animal` 对象和一个 `Dog` 对象，并调用它们的 `makeSound()` 方法和 `name` 属性。由于 `Dog` 继承自 `Animal`，所以它也继承了 `name` 属性，我们可以通过 `dog.name` 来访问它

#### ?implements ####

> 在 Java 中，`implements` 是一种关键字，用于表示一个类实现了一个或多个接口。通过实现接口，类可以获得接口中定义的方法和常量，并提供自己的实现。
> 
> 下面是一个简单的 Java 代码示例，演示了如何使用 `implements` 关键字实现一个接口：
> 
>     public interface Shape {
>          
>         double getArea();
>         double getPerimeter();
>     }
>     
>     public class Circle implements Shape {
>          
>         private double radius;
>         
>         public Circle(double radius) {
>          
>             this.radius = radius;
>         }
>         
>         @Override
>         public double getArea() {
>          
>             return Math.PI * radius * radius;
>         }
>         
>         @Override
>         public double getPerimeter() {
>          
>             return 2 * Math.PI * radius;
>         }
>     }
>     
>     public class Main {
>          
>         public static void main(String[] args) {
>          
>             Circle circle = new Circle(5);
>             System.out.println("Area of the circle: " + circle.getArea());
>             System.out.println("Perimeter of the circle: " + circle.getPerimeter());
>         }
>     }
> 
> 在上面的例子中，`Shape` 接口定义了两个方法 `getArea()` 和 `getPerimeter()`，它们分别返回图形的面积和周长。`Circle` 类实现了 `Shape` 接口，并提供了自己的实现。在 `Main` 类中，我们创建了一个 `Circle` 对象，并调用它的 `getArea()` 和 `getPerimeter()` 方法，它们返回了圆的面积和周长。
> 
> 需要注意的是，一个类可以实现多个接口，多个接口之间用逗号分隔。如果一个类实现了多个接口，它必须实现每个接口中定义的方法

#### ?interface ####

> 在 Java 中，`interface` 是一种特殊的抽象类，它只包含常量和抽象方法的声明。通过实现接口，类可以获得接口中定义的方法和常量，并提供自己的实现。
> 
> 下面是一个简单的 Java 代码示例，演示了如何定义和实现一个接口：
> 
>     public interface Animal {
>          
>         void makeSound();
>     }
>     
>     public class Dog implements Animal {
>          
>         @Override
>         public void makeSound() {
>          
>             System.out.println("The dog barks");
>         }
>     }
>     
>     public class Cat implements Animal {
>          
>         @Override
>         public void makeSound() {
>          
>             System.out.println("The cat meows");
>         }
>     }
>     
>     public class Main {
>          
>         public static void main(String[] args) {
>          
>             Animal dog = new Dog();
>             dog.makeSound(); // 输出 "The dog barks"
>             
>             Animal cat = new Cat();
>             cat.makeSound(); // 输出 "The cat meows"
>         }
>     }
> 
> 在上面的例子中，`Animal` 接口定义了一个 `makeSound()` 方法，表示动物会发出声音。`Dog` 类和 `Cat` 类实现了 `Animal` 接口，并提供了自己的实现。在 `Main` 类中，我们创建了一个 `Dog` 对象和一个 `Cat` 对象，并将它们声明为 `Animal` 类型。由于 `Dog` 和 `Cat` 都实现了 `Animal` 接口，所以它们都有 `makeSound()` 方法。我们可以通过调用 `dog.makeSound()` 和 `cat.makeSound()` 来分别听到狗叫和猫叫的声音。
> 
> 需要注意的是，接口中的方法默认是 `public abstract` 类型，常量默认是 `public static final` 类型，因此不需要显式地指定。接口不能包含构造方法，因为它们不会被继承

#### ?class ####

> 在 Java 中，`class` 是一种定义对象属性和行为的模板。类是面向对象编程的核心概念之一，它用于组织和封装数据和代码，以实现高内聚和低耦合的设计。
> 
> 下面是一个简单的 Java 代码示例，演示了如何定义和使用一个类：
> 
>     public class Car {
>          
>         private String make;
>         private String model;
>         private int year;
>         
>         public Car(String make, String model, int year) {
>          
>             this.make = make;
>             this.model = model;
>             this.year = year;
>         }
>         
>         public void start() {
>          
>             System.out.println("The car is starting...");
>         }
>         
>         public void stop() {
>          
>             System.out.println("The car is stopping...");
>         }
>         
>         public void drive(int miles) {
>          
>             System.out.println("The car is driving " + miles + " miles...");
>         }
>         
>         public String getMake() {
>          
>             return make;
>         }
>         
>         public String getModel() {
>          
>             return model;
>         }
>         
>         public int getYear() {
>          
>             return year;
>         }
>     }
>     
>     public class Main {
>          
>         public static void main(String[] args) {
>          
>             Car car = new Car("Toyota", "Camry", 2021);
>             System.out.println("Make: " + car.getMake());
>             System.out.println("Model: " + car.getModel());
>             System.out.println("Year: " + car.getYear());
>             car.start();
>             car.drive(10);
>             car.stop();
>         }
>     }
> 
> 在上面的例子中，我们定义了一个 `Car` 类，它有三个私有属性 `make`、`model` 和 `year`，以及三个公共方法 `start()`、`stop()` 和 `drive()`，用于启动、停止和驾驶车辆。我们还为每个属性提供了公共的 `getter` 方法，以便可以在外部访问它们的值。
> 
> 在 `Main` 类中，我们创建了一个 `Car` 对象，并通过调用它的 `getMake()`、`getModel()` 和 `getYear()` 方法来获取车辆的制造商、型号和年份。我们还调用了 `start()`、`drive()` 和 `stop()` 方法来启动、驾驶和停止车辆。
> 
> 需要注意的是，Java 中的类可以继承其他类，从而扩展已有的类，并在其基础上添加新的属性和方法。此外，类还可以实现接口，以获得接口中定义的方法和常量。通过使用类的继承和实现，可以实现代码的重用和多态

#### ?new ####

> 在 Java 中，`new` 是一种用于创建新对象的操作符。它可以在内存中分配一段新的空间，并返回一个指向该空间的对象引用。使用 `new` 操作符创建对象的过程称为实例化。
> 
> 下面是一个简单的 Java 代码示例，演示了如何使用 `new` 操作符创建对象：
> 
>     public class Car {
>          
>         private String make;
>         private String model;
>         private int year;
>         
>         public Car(String make, String model, int year) {
>          
>             this.make = make;
>             this.model = model;
>             this.year = year;
>         }
>         
>         public void start() {
>          
>             System.out.println("The car is starting...");
>         }
>         
>         public void stop() {
>          
>             System.out.println("The car is stopping...");
>         }
>         
>         public void drive(int miles) {
>          
>             System.out.println("The car is driving " + miles + " miles...");
>         }
>         
>         public String getMake() {
>          
>             return make;
>         }
>         
>         public String getModel() {
>          
>             return model;
>         }
>         
>         public int getYear() {
>          
>             return year;
>         }
>     }
>     
>     public class Main {
>          
>         public static void main(String[] args) {
>          
>             Car car = new Car("Toyota", "Camry", 2021);
>             System.out.println("Make: " + car.getMake());
>             System.out.println("Model: " + car.getModel());
>             System.out.println("Year: " + car.getYear());
>             car.start();
>             car.drive(10);
>             car.stop();
>         }
>     }
> 
> 在上面的例子中，我们使用 `new` 操作符创建了一个 `Car` 对象，并将它赋值给 `car` 变量。我们传递了三个参数 `"Toyota"`、`"Camry"` 和 `2021` 给 `Car` 类的构造函数，以初始化对象的属性。然后，我们可以使用 `car` 变量调用 `getMake()`、`getModel()` 和 `getYear()` 方法来获取对象的属性值，并调用 `start()`、`drive()` 和 `stop()` 方法来执行对象的行为。
> 
> 需要注意的是，Java 中的 `new` 操作符只能用于实例化类的对象，而不能用于实例化接口或抽象类。此外，使用 `new` 操作符创建对象时，Java 会自动调用对象的构造函数来初始化对象的属性。如果类没有提供任何构造函数，则Java会自动提供一个默认的无参构造函数。如果需要提供特定的构造函数，则必须在类中显式地定义

### ☢自动装箱&拆箱 ###

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>java.Lang.Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>java.Lang.Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>java.Lang.Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>java.Lang.Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>java.Lang.Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>java.Lang.Double</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>java.Lang.Boolean</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>java.Lang.Character</td> 
  </tr> 
 </tbody> 
</table>

![在这里插入图片描述][da81030c9f0d4fa696185ae41d93a82e.png_pic_center]

> 装箱：基本类型——转换为——对应的包装类类型，一般使用方法valueOf（）方法实现
> 
> 拆箱：包装类类型——转换为——对应的基本数据类型，一般使用类中提供xxxValue（）方法实现

>  *  自动装箱
> 
> Integer i = 100；
> 
> i += 200 // i = i + 200 ；i + 200 自动拆箱 ； i = i + 200 自动装箱

package itiheima_04;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
    
            //装箱：基本类型转换为对应的包装类类型
            Integer i = Integer.valueOf(100);
            //自动装箱
            Integer ii = 100;   //省略了 Integer.valueOf(100);
    
            //拆箱：包装类类型转换为对应的基本数据类型
            ii = ii.intValue() + 200;
            //自动拆箱
            ii += 200;
        }
    }

### ☢方法重写 & 方法重载 ###

#### ?方法重写 ####

>  *  子类出现和父类一模一样的方法声明
>  *  当子类需要父类的功能，而功能主体子类有自己的特有内容时，可以重写父类中的方法，这样即沿袭父类的功能，又定义了子类特有的内容
>  *  私有方法不能重写
>  *  子类方法访问权限不能比父类低（public > default > private）

>  *  Phone类
> 
>     public class Phone {
>          
>         public void call(String name) {
>          
>             System.out.println("给" + name + "打电话");
>         }
>     }
> 
>  *  NewPhone类
> 
>     public class NewPhone extends Phone{
>          
>     
>         //重写父类方法
>         @Override
>         public void call(String name) {
>          
>             super.call(name);
>             System.out.println("开启视频功能");
>         }
>     }
> 
>  *  Demo测试类
> 
>     public class PhoneDemo {
>          
>         public static void main(String[] args) {
>          
>     
>             Phone phone = new Phone();
>             phone.call("weishuo");
>     
>             System.out.println("=====================");
>     
>             NewPhone newPhone = new NewPhone();
>             newPhone.call("tian");
>         }
>     }

#### ?方法重载 ####

> 方法重载前提：方法名相同、参数列不同、与返回值无关
> 
>  *  多个方法在一个类中
>  *  多个方法具有相同方法名
>  *  多个方法参数不相同、类型不同、数量不同

public class MethodDemo {
        
        public static void main(String[] args) {
        
            System.out.println(sum(1, 1));
            System.out.println(sum(1.1, 1.1));
            System.out.println(sum(1, 1, 1));
        }
    
        //需求1：求两个int类型数据和的方法
        public static int sum(int a, int b) {
        
            return a + b;
        }
    
        //需求2：求两个double类型数据和的方法
        public static double sum(double a, double b) {
        
            return a + b;
        }
    
        //需求3：求两个int类型数据和的方法
        public static int sum(int a, int b, int c) {
        
            return a + b + c;
        }
    }

### ☢日期 ###

#### ?Date ####

> Date代表一个特定的时间，精确到毫秒

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public Date()</td> 
   <td>分配一个Date对象，并初始化，以便它代表被分配的时间</td> 
  </tr> 
  <tr> 
   <td>public Date(long date)</td> 
   <td>分配一个Date对象，将其初始化表示从标准基准时间起指定的毫秒数</td> 
  </tr> 
  <tr> 
   <td>piblic long getTime()</td> 
   <td>获取日期对象从1970年1月1日00:00:00到现在的毫秒值</td> 
  </tr> 
  <tr> 
   <td>public void getTime(long time)</td> 
   <td>设置时间，给的是毫秒值</td> 
  </tr> 
 </tbody> 
</table>

public class SimpleDateFormat {
        
        public static void main(String[] args) {
        
    
            //public Date()
            Date d1 = new Date();
            System.out.println(d1); // Sun Nov 20 15:44:32 CST 2022
    
            System.out.println("=================");
    
            //public Date(long date)
            long date2 = 1000*60*60;
            Date d2 = new Date(date2);
            System.out.println(d2); // Thu Jan 01 09:00:00 CST 1970
        }
    }

#### ?SimpleDateFormat ####

![在这里插入图片描述][6d7a911cb2c441088bb319eb56a586f3.png_pic_center]

> SimpleDateFormat是一个具体类，用于区域设置敏感的方式格式化和解析日期

<table> 
 <thead> 
  <tr> 
   <th>yyyy-MM-dd HH:mm:ss</th> 
   <th>常用的模式字母对应关系</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>y</td> 
   <td>年</td> 
  </tr> 
  <tr> 
   <td>M</td> 
   <td>月</td> 
  </tr> 
  <tr> 
   <td>d</td> 
   <td>日</td> 
  </tr> 
  <tr> 
   <td>H</td> 
   <td>时</td> 
  </tr> 
  <tr> 
   <td>m</td> 
   <td>分</td> 
  </tr> 
  <tr> 
   <td>s</td> 
   <td>秒</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SimpleDateFormat()</td> 
   <td>构建了一个 SimpleDateFormat，使用默认模式和日期格式</td> 
  </tr> 
  <tr> 
   <td>SimpleDateFormat(String pattern)</td> 
   <td>构建了一个 SimpleDateFormat使用给定的模式和默认的日期格式</td> 
  </tr> 
 </tbody> 
</table>

>  *  格式化（Date——>String）
>     
>     public final String format(Date date) 将日期格式化成日期/时间字符串
>  *  解析（String——>Date）
>     
>     public Date parse(String source) 从给定的字符串开始解析文本以生成日期

public class SimpleDateFormatDemo {
        
        public static void main(String[] args) throws ParseException {
        
    
            //格式化（Date——>String）
            Date date1 = new Date();
            SimpleDateFormat sdf1 = new SimpleDateFormat();     //默认模式
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    //自定义模式
    
            //格式化输出
            System.out.println(sdf1.format(date1));  //  22-11-20 下午4:03
            System.out.println(sdf2.format(date1));  //  2022-11-20 16:05:57
    
    
            //解析（String——>Date）
            String s = "2022-11-20 08:08:08";
            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    //自定义模式
            System.out.println(sdf3.parse(s));  // Sun Nov 20 08:08:08 CST 2022
        }
    }

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

> ? 结语：创作不易，如果觉得博主的文章赏心悦目，还请——`点赞`?`收藏`⭐️`评论`?`冲冲冲`?

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

![在这里插入图片描述][d3ab6ddb82c2490abc1a7836a1dc557c.gif_pic_center]

[acb8a7e0bf334001af9f95d515c4f452.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/8e0a359d8bde43e4b2c4269e9991f887.gif
[wei_shuo]: https://blog.csdn.net/weixin_62765017
[wei_shuo 1]: https://bbs.csdn.net/forums/wei_shuo_study
[7aee1e04c10a4f629b34f7be6199cfa1.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/163b217ebafe4f7cb784a786c403d490.png
[46a6a4dd508e44519512857f6ee311cb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/ff0476a6ec7c4499b1a27c49cc341937.png
[90ed86c9220846689e2bda5390fea5de.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e5f81ad1e694463381b26ad3b91890af.png
[7c3154a09be9406ca9ceaa6f57fe2201.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/977b1dac03004e1297f5ed4fbb1b2a54.png
[a09e51e9c4f94697b0703244c8f543d6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/3ea85d924870477d8ba6b92013f7009a.png
[5119f6b5c8e04416badefe9fd998719a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/b95f680c9dda4eeab56552001afad019.png
[9603590fe3bf4c10a12c974c242a490e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/028a1026048d45c6b71d17f99f28cd41.png
[da81030c9f0d4fa696185ae41d93a82e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/1b8ebd69576448329be7f9a10d544a24.png
[6d7a911cb2c441088bb319eb56a586f3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/47171370094542e7a18d1c03dbcc7b36.png
[d3ab6ddb82c2490abc1a7836a1dc557c.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/fc7008d8f48b464a9652b42cdc18a866.gif