java基础篇：继承和抽象（super、this关键字）

待我称王封你为后i 2022-12-03 15:56 169阅读 0赞

# java基础篇 #

# IDEA常用快捷键 #

<table> 
 <thead> 
  <tr> 
   <th>快捷键</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Alt+Enter</td> 
   <td>自动修正代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Y</td> 
   <td>删除光标所在行</td> 
  </tr> 
  <tr> 
   <td>Ctrl+D</td> 
   <td>复制光标所在行的内容，插入光标位置下面</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Alt +L</td> 
   <td>格式化代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+/</td> 
   <td>单行注释，再按取消注释</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Shift+/</td> 
   <td>选中代码注释，多行注释，再按取消注释。</td> 
  </tr> 
  <tr> 
   <td>Alt+Ins</td> 
   <td>自动生成代码，toString，get，set等方法</td> 
  </tr> 
  <tr> 
   <td>Alt+Shift+上下箭头</td> 
   <td>移动当前代码行</td> 
  </tr> 
 </tbody> 
</table>

# 继承的概述 #

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

## 继承的格式 ##

创建对象

package Extends;
    /* * 在继承的关系中："子类就是一个父类"。也就是说：子类可以被当做父类看待。 * 例如：父类是员工，子类是讲师，那么"讲师就是一个员工"。关系：is-a * * 定义父类的格式：（一个普通的类定义） * public class 父类名称 { * // ... * } * 定义子类的格式： * public class 子类名称 extends 父类名称 { * // ... * } * */
    public class Demo01Extends { 
        public static void main(String[] args) { 
            // 创建了一个子类对象
            Teacher teacher = new Teacher();
            // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
            teacher.method();
    
            // 创建了一个子类助教
            Assistant assistant = new Assistant();
            // Assistant类当中虽然什么都没写，但是会继承来自父类的method方法。
            assistant.method();
        }
    }

定义一个父类：员工

package Extends;
    // 定义一个父类：员工
    public class Employee { 
        // 定义一个方法
        public void method() { 
            System.out.println("方法执行");
        }
    }

*  定义子类：讲师

package Extends;
    /* * 定义了一个员工的子类：讲师 * */
    public class Teacher extends Employee{ 
    
    }

*  定义子类：助教

package Extends;
    // 定义了一个员工的子类：助教
    public class Assistant extends Employee { 
    
    }

## 继承中成员变量的访问特点 ##

package Extends.Demo01;
    /* * 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式： * * 直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。 * 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找。 * */
    public class Demo01ExtendsField { 
        public static void main(String[] args) { 
            Fu fu = new Fu(); // 创建父类对象
            System.out.println(fu.numFu); // 20 只能使用父类的东西，没有任何子类的内容
    
            Zi zi = new Zi(); // 创建子类对象
            System.out.println(zi.numZi); // 10
            System.out.println(zi.numFu); // 20
            System.out.println("=============");
    
            // 等号左边是谁，就优先用谁，没有则向上找
            System.out.println(zi.num); // 100 优先子类 Zi zi = new Zi();
            // System.out.println(zi.abc); // 到处都没有，编译报错!
            System.out.println("=============");
    
            // 这个方法是子类的，优先用子类的，没有再向上找
            zi.methodZi(); // 100
            // 这个方法是在父类当中定义的
            zi.methodFu(); // 200
        }
    }

*  父类

package Extends.Demo01;
    
    public class Fu { 
        // 成员变量
        int numFu = 20;
        int num = 200;
        // 成员方法
        public void methodFu() { 
            // 使用的是本类当中的，不会向下找子类的
            System.out.println(num);
        }
    }

*  子类

package Extends.Demo01;
    
    public class Zi extends Fu{ 
        // 成员变量
        int numZi = 10;
        int num = 100;
        // 成员方法
        public void methodZi() { 
            // 因为本类当中有num,所以这里用的是本类的num
            System.out.println(num);
        }
    }

## 区分子类方法中重名的三种变量 ##

package Extends.Demo02;
    /* * 局部变量： 直接写成员变量名 * 本类的成员变量： this.成员变量名 * 父类的成员变量： super.成员变量名 * */
    public class Demo01ExtendsField { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
            zi.method();
        }
    }

*  父类

package Extends.Demo02;
    
    public class Fu { 
        int num = 20;
    }

*  子类

package Extends.Demo02;
    
    public class Zi extends Fu{ 
        int num = 10;
        public void method() { 
            int num = 30;
            System.out.println(num); // 30 局部变量
            System.out.println(this.num); // 10 本类的成员变量
            System.out.println(super.num); // 20 父类的成员变量
        }
    }

## 继承中成员方法的访问特点 ##

package Extends.Demo03;
    /* * 在父子类的继承关系当中，创建子类对象，访问成员方法的规则： * 创建的对象是谁，就优先用谁，如果没有则向上找。 * * 注意事项： * 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。 * */
    public class Demo01ExtendsMethod { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
    
            zi.methodFu(); // 父类方法执行
            zi.methodZi(); // 子类方法执行
    
            // 创建的是new了子类对象，所以优先用子类方法
            zi.method(); // 子类重名方法执行
        }
    }

*  父类

package Extends.Demo03;
    
    public class Fu { 
        public void methodFu(){ 
            System.out.println("父类方法执行");
        }
    
        public void method(){ 
            System.out.println("父类重名方法执行");
        }
    }

*  子类

package Extends.Demo03;
    
    public class Zi extends Fu{ 
        public void methodZi(){ 
            System.out.println("子类方法执行");
        }
    
        public void method(){ 
            System.out.println("子类重名方法执行");
        }
    }

## 继承中方法的覆盖重写：概念与特点 ##

package Extends.Demo03;
    /* * 在父子类的继承关系当中，创建子类对象，访问成员方法的规则： * 创建的对象是谁，就优先用谁，如果没有则向上找。 * * 注意事项： * 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。 * 重写（Override） * 概念：在继承关系当中，方法的名称一样，参数列表也一样。 * * 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。 * 重载（Overload）：方法的名称一样，参数列表【不一样】。 * * 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。 * */
    public class Demo01ExtendsMethod { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
    
            zi.methodFu(); // 父类方法执行
            zi.methodZi(); // 子类方法执行
    
            // 创建的是new了子类对象，所以优先用子类方法
            zi.method(); // 子类重名方法执行
        }
    }

*  父类

*  子类

## 继承中方法的覆盖重写：注意事项 ##

package Extends.Demo04;
    /* * 方法覆盖重写的注意事项： * * 1.必须保证父子类之间方法的名称相同，参数列表也相同 * @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。 * 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。 * * 2.子类方法的返回值必须【小于等于】父类方法的返回值范围 * 小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。 * * 3.子类方法的权限必须【大于等于】父类方法的权限修饰符。 * 小扩展提示：public > protected > (default) > private * 备注：(default)不是关键字default，而是什么都不写，留空。 * */
    public class Demo04Override { 
        public static void main(String[] args) { 
    
        }
    }

*  父类

package Extends.Demo04;
    
    public class Fu { 
        public Object method() { 
            return null;
        }
    }

*  子类

package Extends.Demo04;
    
    public class Zi extends Fu{ 
        @Override
        public Object method() { 
            return null;
        }
    }

## 继承中方法的覆盖重写：应用场景 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 1]

package Extends.Demo05;
    
    public class Demo01Phone { 
        public static void main(String[] args) { 
            Phone phone = new Phone();
            phone.call(); // 打电话
            phone.send(); // 发短信
            phone.show(); // 显示号码
            System.out.println("==========");
            newPhone newPhone = new newPhone();
            newPhone.call(); // 打电话
            newPhone.send(); // 发短信
            newPhone.show(); // 显示号码 显示姓名 显示头像
                    
        }
    }

*  父类

package Extends.Demo05;
    // 本来的老款手机
    public class Phone { 
        public void call() { 
            System.out.println("打电话");
        }
    
        public void send() { 
            System.out.println("发短信");
        }
    
        public void show() { 
            System.out.println("显示号码");
        }
    }

*  子类

package Extends.Demo05;
    // 定义一个新手机，使用老手机作为父类
    public class newPhone extends Phone{ 
        @Override
        public void show(){ 
            super.show(); // 把父类的show方法拿过来重复利用
            // 自己子类再来添加更多内容
            System.out.println("显示姓名");
            System.out.println("显示头像");
        }
    }

## 继承中构造方法的访问特点 ##

package Extends.Demo06;
    /* * 继承关系中，父子类构造方法的访问特点： * 1.子类构造方法当中有一个默认隐含的"super()"调用，所以一定是先调用的父类构造，后执行的子类构造 * 2.子类构造可以通过super关键字，调用父类重载构造 * 3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。 * * 总结： * 1.子类必须调用父类构造方法：不写则赠送super(); * 写了则用写的指定的super调用，super只能有一个，还必须是第一个 * */
    public class Demo06Constructor { 
        public static void main(String[] args) { 
            // 创建子类对象
            Zi zi = new Zi();
        }
    }

*  父类

package Extends.Demo06;
    
    public class Fu { 
        // 有参构造
        public Fu(int num){ 
            System.out.println("父类有参构造方法");
        }
    
        // 无参构造
        public Fu(){ 
            System.out.println("父类无参构造方法");
        }
    
    }

*  子类

package Extends.Demo06;
    
    public class Zi extends Fu{ 
        // 无参构造
        public Zi(){ 
            // super(); // 在调用父类无参构造方法
            super(20); // 调用父类重载的构造方法
            System.out.println("子类构造方法");
        }
    
    // public void method() { 
    // super(); // 错误写法! 只有子类构造方法，才能调用父类构造方法。
    // }
    }

# super关键字的三种用法 #

package Extends.Demo07;
    
    public class Demo07Super { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
            zi.method();
            zi.methodZi();
        }
    }

*  父类

package Extends.Demo07;
    
    public class Fu { 
        int num = 30;
    
        public void method() { 
            System.out.println("父类方法");
        }
    }

*  子类

package Extends.Demo07;
    /* * super关键字的用法有三种： * 1.在子类的成员方法中，访问父类的成员变量。 * 2.在子类的成员方法中，访问父类的成员方法。 * 3.在子类的构造方法中，访问父类的构造方法。 * */
    public class Zi extends Fu{ 
        int num = 20;
    
        public Zi() { 
            super();
        }
    
        public void methodZi() { 
            System.out.println(num); // 20
            System.out.println(super.num); // 父类中的30
        }
    
        public void method() { 
            super.method(); // 访问父类中的method
            System.out.println("子类方法");
        }
    }

# this关键字的三种用法 #

package Extends.Demo08;
    
    public class Fu { 
        int num = 30;
    }

package Extends.Demo08;
    /* * super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种。 * 1.在本类的成员方法中，访问本类的成员变量。 * 2.在本类的成员方法中，访问本类的另一个成员方法。 * 3.在本类的构造方法中，访问本类的另一个构造方法。 * 注意事项： * 1.this(...) 调用也必须是构造方法的第一个语句。【唯一一个】 * 2.super和this两种构造调用，不能同时使用 * */
    public class Zi extends Fu{ 
        int num = 20;
    	
        // 无参构造
        public Zi() { 
            // super(); // 这一行不再赠送
            this(123); // 本类的无参构造，调用本类的有参构造
            // this(12,13); // 错误写法【注意事项1】
        }
    	// 有参构造
        public Zi(int n) { 
            this(1,2); // 一个参数，可以调用多个参数
        }
    	// 有参构造
        public Zi(int n,int m) { 
            // this(6); // 多个参数不能调用一个参数
        }
    
        public void showNum() { 
            int num = 10;
            System.out.println(num); // 局部变量
            System.out.println(this.num); // 本类中的成员变量
            System.out.println(super.num); // 父类中的成员变量
        }
    
        public void methodA() { 
            System.out.println("AAA");
        }
    
        public void methodB() { 
            this.methodA(); // 在本类的成员方法中，访问本类的另一个成员方法
            System.out.println("BBB");
        }
    }

# super与this关键字图解 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 2]

# Java继承的三个特点 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 3]

# 抽象的概念： #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 4]

## 抽象方法和抽象类的格式 ##

package Extends.Demo10;
    /* * 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结算。 * 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。 * */
    public abstract class Animal { 
        // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
        public abstract void eat();
        
        // 这是普通的成员方法
        public void normalMethod() { 
            
        }
    }

## 抽象方法和抽象类的使用 ##

package Extends.Demo10;
    
    public class Demo01Main { 
        public static void main(String[] args) { 
            // Animal animal = new Animal(); // 错误写法：第一步：不能直接创建new抽象类对象
    
            // 第四步：创建子类对象进行使用
            Cat cat = new Cat();
            cat.eat();
        }
    }

*  父类

package Extends.Demo10;
    /* * 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结算。 * 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。 * * 如何使用抽象类和抽象方法： * 1.不能直接创建new抽象类对象。 * 2.必须用一个子类来继承抽象父类。 * 3.子类必须覆盖重写抽象父类当中所有的抽象方法。 * 覆盖重写（实现），子类去掉抽象方法的 abstract 关键字，然后补上方法体大括号 * 4.创建子类对象进行使用。 * */
    public abstract class Animal { 
        // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
        public abstract void eat();
    
        // 这是普通的成员方法
        public void normalMethod() { 
    
        }
    }

*  子类

package Extends.Demo10;
    
    // 第二步：用一个子类来继承抽象父类
    public class Cat extends Animal{ 
    
        /* * 第三步：子类必须覆盖重写抽象父类当中所有的抽象方法。 * 覆盖重写（实现），子类去掉抽象方法的 abstract 关键字，然后补上方法体大括号 * */
    
        @Override
        public void eat() { 
            System.out.println("猫吃鱼");
        };
    }

## 抽象方法和抽象类的注意事项： ##

关于抽象类的使用，以下为语法上要注意的细节

1.  抽象类【**不能创建对象**】。如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    
    > 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2.  抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    
    > 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法
    
        package Extends.Demo11;
        
        public class DemoMain { 
            public static void main(String[] args) { 
                Zi zi = new Zi();
                zi.eat();
            }
        }
    
     *  父类
    
        package Extends.Demo11;
        // 抽象父类
        public abstract class Fu { 
        
            public Fu() { 
                System.out.println("抽象父类构造方法执行");
            }
        
            public abstract void eat();
        }
    
     *  子类
    
        package Extends.Demo11;
        
        public class Zi extends Fu{ 
        
            public Zi() { 
                // super(); // 通过赠送的super();运行父类中的 Fu 构造方法
                System.out.println("子类构造方法执行");
            }
        
            @Override
            public void eat() { 
                System.out.println("吃饭饭");
            }
        }
3.  抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    
    ###### 【抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可】 ######
    
    > 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
    
        package Extends.Demo11;
        /* * 一个抽象类不一定含有抽象方法， * 只要保证抽象方法所在的类是抽象类，即可。 * * 这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。 * */
        public abstract class MyAbstract { 
        
        }
4.  抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
    
    > 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

# 发红包案例-分析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 5]

# 发红包案例-实现 #

package SendMoney;
    
    import java.util.ArrayList;
    
    public class MainPacket { 
        public static void main(String[] args) { 
    
            // 群主对象
            Manager manager = new Manager("群主",100);
    
            Member one = new Member("成员A",0);
            Member two = new Member("成员B",0);
            Member three = new Member("成员B",0);
    
            manager.show();
            one.show();
            two.show();
            three.show();
            System.out.println("============");
    
            // 群主总共发20块钱，分成3个红包
            ArrayList<Integer> redList = manager.send(20,3);
            // 三个普通成员收红包
            one.receive(redList);
            two.receive(redList);
            three.receive(redList);
    
            manager.show(); // 100-20=80
            // 6,6,8 随机分给三个人
            one.show();
            two.show();
            three.show();
        }
    }

*  群主

package SendMoney;
    
    import java.util.ArrayList;
    
    // 群主的类
    public class Manager extends User{ 
        public Manager() { 
    
        }
        // 快捷键：Alt + insert
        public Manager(String name, int money) { 
            super(name, money);
        }
        public ArrayList<Integer> send(int totalMoney,int count) { 
    
            // 首先需要一个集合，用来存储若干个红包的金额
            ArrayList<Integer> redList = new ArrayList();
    
            // 首先看一下群主自己有多少钱
            int leftMoney = super.getMoney(); // 群主当前余额
            if(totalMoney > leftMoney) { 
                System.out.println("余额不足");
                return redList; // 返回空集合
            }
    
            // 扣钱，其实就是重新设置余额
            super.setMoney(leftMoney - totalMoney);
    
            // 发红包需要平均拆分成为count份
            int avg = totalMoney / count;
            int mod = totalMoney % count; // 余数，也就是甩下的零头
    
            // 除不开的零头，包在最后一个红包当中
            // 下面把红包一个一个放到集合当中
            for (int i = 0; i < count; i++) { 
                redList.add(avg);
            }
    
            // 最后一个红包
            int last = avg + mod;
            redList.add(last);
    
            return redList;
        }
    }

*  用户类

package SendMoney;
    
    public class User { 
    
        private String name; // 姓名
        private int money; // 余额，也就是当前用户拥有的钱数
    
        // 无参构造
        public User() { 
        }
    
        // 有参构造
        public User(String name, int money) { 
            this.name = name;
            this.money = money;
        }
    
        // 展示一下当前用户有多少钱
        public void show() { 
            System.out.println("我叫：" + name + ",我有多少钱：" + money);
        }
    
        // Getter/Setter方法
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getMoney() { 
            return money;
        }
    
        public void setMoney(int money) { 
            this.money = money;
        }
    }

*  成员

package SendMoney;
    
    import java.util.ArrayList;
    import java.util.Random;
    // 普通成员
    public class Member extends User{ 
        public Member() { 
    
        }
        public Member(String name,int money) { 
            super(name, money);
        }
        public void receive(ArrayList<Integer> list) { 
            // 从多个红包当中随便抽取一个，给我自己
            // 随机获取一个集合当中的索引编号
            int index = new Random().nextInt(list.size());
            // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
            Integer delta = list.remove(index);
            // 当前成员自己本来有多少钱
            int money = super.getMoney();
            // 加法，并且重新设置回去
            super.setMoney(money + delta);
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/6f149b2e6bb042d3b1483c37643e8839.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/4080fb49fba141ff8b868fe5c502d9ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/b303bac4d3a34b02970f98fbd9b228eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/b71aaca5ca684cbeb07619c087aa2749.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/a418770d93b9457a8f0e95fd8877763c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/74532d58fe144c66b205d490310edcc7.png