23、房屋出租系统

亦凉 2024-04-01 18:04 69阅读 0赞

1、项目需求说明：

实现基于文本界面的《房屋出租软件》，能够实现对房屋信息的添加、修改和删除（用数组实现），并能够打印房屋明细表

2、项目界面：

主菜单：

![40aa2c6c4ad94ee3b462429ae160d036.png][]

新增房源：

![ef2d8927bf2b44548e105e9238d16ebe.png][]

查找房源：

![85ffb390ef9d44288834e3412aa81f8c.png][]

删除房源：

![cdf339752c5e461c8446535bf5f1e02f.png][]

修改房源：（如果不希望修改某个信息，则直接回车）

![5ce780e9e4cf4093b4b7b2d2dc9b5c7c.png][]

房屋列表：

![90f4d315f88d4ca98c457f6cc6e57349.png][]

退出系统：

![68a8efe1c9434e5cb2720b58c76c562a.png][]

3、项目设计-程序框架图（分层模式——》当软件比较复杂，需要模式管理）

![f5575281acb647acb54f4703301232f9.png][]

![127cdef60ac94c1fa0052147de05abe2.png][]

4、准备工具类Utility，提高开发效率

*在实际开发中，公司都会提供相应的工具类和开发库，可以提高开发效率，程序员也需要能够看懂别人写的代码，并能够正确地调用*

（1）了解Utility类的使用

（2）测试Utility类

5、代码具体实现：

（1）House类

package houseserent.domain;
    
    public class House {
        private int id;//房间编号
        private String name;//房主
        private String phone;//电话
        private String address;//地址
        private int rent;//月租
        private String state;//状态（是否已出租）
    
        public House(int id, String name, String phone, String address, int rent, String state) {
            this.id = id;
            this.name = name;
            this.phone = phone;
            this.address = address;
            this.rent = rent;
            this.state = state;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public int getRent() {
            return rent;
        }
    
        public void setRent(int rent) {
            this.rent = rent;
        }
    
        public String getState() {
            return state;
        }
    
        public void setState(String state) {
            this.state = state;
        }
    
        @Override
        public String toString() {
            return id +
                    "\t" + name +
                    "\t" + phone +
                    "\t" + address +
                    "\t" + rent +
                    "\t" + state ;
        }
    }

（2）显示主菜单和完成退出软件功能：

*实现功能的三部曲：*

*1）功能说明：用户打开软件，可以看到主菜单，可以退出软件*

*2）思路分析：在HouseView.java中，编写一个方法mainMenu，显示菜单*

*3）代码实现：*

package houseserent.view;
    
    import houseserent.utils.Utility;
    
    public class HouseView {
        private boolean loop=true;//控制显示菜单
        private char key=' ';//接收用户选择
        public  void mainMenu(){//显示主菜单
            do{
                System.out.println("---------------房屋出租系统菜单----------------");
                System.out.println("\t\t\t1 新 增 房 源");
                System.out.println("\t\t\t2 查 找 房 屋");
                System.out.println("\t\t\t3 删 除 房 屋 信 息");
                System.out.println("\t\t\t4 修 改 房 屋 信 息");
                System.out.println("\t\t\t5 房 屋 列 表");
                System.out.println("\t\t\t6 退       出");
                System.out.println("请输入你的选择（1-6）");
                key = Utility.readChar();
                switch(key){
                    case '1':
                        System.out.println("新增");
                        break;
                    case '2':
                        System.out.println("查找");
                        break;
                    case '3':
                        System.out.println("删除");
                        break;
                    case '4':
                        System.out.println("修改");
                        break;
                    case '5':
                        System.out.println("房屋列表");
                        break;
                    case '6':
                        System.out.println("退出");
                        loop=false;
                        break;
                }
    
            }while(loop);
        }
    }

（3）添加房屋信息的功能：

（4）完成删除房屋信息的功能：

package houseserent.service;
    
    import houseserent.domain.House;
    
    public class HouseService {
        private House[] houses;//保存House对象
        private int houseNums=1;//记录当前有多少个房屋信息
        private int idCounter=1;//记录的id增长到哪里
        public HouseService(int size){
            houses=new House[size];//当创建HouseService对象时，指定大小
            houses[0]=new House(1,"jack","112","海淀区",2000,"未出租");
        }
        public boolean del(int delId){//删除一个房屋信息
            //注意下标和房屋编号无关系
            int index=-1;
            for(int i=0;i<houseNums;i++){
                if(delId==houses[i].getId()){//要删除的房屋（if），是数组下标为i的元素
                    index=i;//用index记录i
                }
            }
            if(index==-1){//说明delId在数组中不存在
                return false;
            }
            for(int i=index;i<houseNums;i++){
                houses[i]=houses[i+1];
            }
            houses[--houseNums]=null;//删掉某个房屋信息后，后面的往前移，最后一个房屋信息置空
            return true;
        }
        public boolean add(House newHouse){//添加新对象
            //判断是否还可以继续添加
            if(houseNums==houses.length){
                System.out.println("数组已满，不能再添加了...");
                return false;
            }
            //把newHouse对象加入到数组
            houses[houseNums++]=newHouse;
            //设计一个id自增长机制，然后更新newHouse的id
            newHouse.setId(++idCounter);
            return true;
        }
        public House[] list(){
            return houses;
        }
    }

（5）完善退出确认功能：

（6）完成根据id查找房屋信息的功能：

package houseserent.service;
    
    import houseserent.domain.House;
    
    public class HouseService {
        private House[] houses;//保存House对象
        private int houseNums=1;//记录当前有多少个房屋信息
        private int idCounter=1;//记录的id增长到哪里
        public HouseService(int size){
            houses=new House[size];//当创建HouseService对象时，指定大小
            houses[0]=new House(1,"jack","112","海淀区",2000,"未出租");
        }
        public House findById(int findId){//返回House对象或者null
            for(int i=0;i<houseNums;i++){
                if(findId==houses[i].getId()){
                    return houses[i];
                }
            }
            return null;
        }
        public boolean del(int delId){//删除一个房屋信息
            //注意下标和房屋编号无关系
            int index=-1;
            for(int i=0;i<houseNums;i++){
                if(delId==houses[i].getId()){//要删除的房屋（if），是数组下标为i的元素
                    index=i;//用index记录i
                }
            }
            if(index==-1){//说明delId在数组中不存在
                return false;
            }
            for(int i=index;i<houseNums;i++){
                houses[i]=houses[i+1];
            }
            houses[--houseNums]=null;//删掉某个房屋信息后，后面的往前移，最后一个房屋信息置空
            return true;
        }
        public boolean add(House newHouse){//添加新对象
            //判断是否还可以继续添加
            if(houseNums==houses.length){
                System.out.println("数组已满，不能再添加了...");
                return false;
            }
            //把newHouse对象加入到数组
            houses[houseNums++]=newHouse;
            //设计一个id自增长机制，然后更新newHouse的id
            newHouse.setId(++idCounter);
            return true;
        }
        public House[] list(){
            return houses;
        }
    }

package houseserent.view;
    
    import houseserent.domain.House;
    import houseserent.service.HouseService;
    import houseserent.utils.Utility;
    import jdk.jshell.execution.Util;
    
    public class HouseView {
        private boolean loop=true;//控制显示菜单
        private char key=' ';//接收用户选择
        private HouseService houseService=new HouseService(10);
        public void findHouse(){//根据id查找房屋信息
            System.out.println("------------查找房屋信息--------------");
            System.out.println("请输入要查找的id：");
            int findId=Utility.readInt();
            House house=houseService.findById(findId);
            if(house!=null){
                System.out.println(house);
            }else{
                System.out.println("-----------查找的房屋信息id不存在-----------");
            }
        }
        public void exit(){//退出确认
            char c=Utility.readConfirmSelection();
            if(c=='Y'){
                loop=false;
            }
        }
        public void delHouse(){
            System.out.println("--------------删除房屋信息-------------");
            System.out.print("请输入待删除房屋的编号（-1退出）：");
            int delId=Utility.readInt();
            if(delId==-1){
                System.out.println("--------------放弃删除房屋信息-------------");
                return;
            }
            char choice=Utility.readConfirmSelection();
            if(choice=='Y') {
                if (houseService.del(delId)) {
                    System.out.println("--------------删除房屋信息成功---------------");
                } else {
                    System.out.println("---------------房屋编号不存在，删除失败----------------");
                }
            }else{
                    System.out.println("-------------放弃删除房屋信息-----------------");
            }
            System.out.print("请确认是否删除（Y/N）小心选择：");
            //readConfirmSelection()这个方法本身就有循环判断的逻辑，必须输入Y/N，否则循环不结束
            choice=Utility.readConfirmSelection();//判断输入的是否是Y/N
            if(choice=='Y'){
    
            }else{
                System.out.println("--------------放弃删除房屋信息--------------");
            }
        }
        public void addHouse(){//接收输入，增加房屋信息
            System.out.println("--------------添加房屋------------");
            System.out.print("姓名：");
            String name= Utility.readString(8);
            System.out.print("电话：");
            String phone=Utility.readString(12);
            System.out.print("地址：");
            String address=Utility.readString(16);
            System.out.print("月租：");
            int rent=Utility.readInt();
            System.out.print("状态：");
            String state=Utility.readString(3);
            //创建一个新的House对象，但id是系统分配的
            House newHouse=new House(0,name,phone,address,rent,state);
            if(houseService.add(newHouse)){
                System.out.println("---------------添加房屋成功-------------");
            }else{
                System.out.println("---------------添加房屋失败-------------");
            }
        }
        public void listHouse(){//显示房屋列表
            System.out.println("-----------------房屋列表--------------");
            System.out.println("编号\t房主\t电话\t地址\t月租\t状态（未出租/已出租）");
            House[] houses=houseService.list();//得到所有房屋信息
            for(int i=0;i<houses.length;i++){
                if(houses[i]==null){//如果为null，就不用再显示了
                    break;
                }
                System.out.println(houses[i]);
            }
            System.out.println("--------------房屋列表显示完毕---------------");
        }
        public  void mainMenu(){//显示主菜单
            do{
                System.out.println("---------------房屋出租系统菜单----------------");
                System.out.println("\t\t\t1 新 增 房 源");
                System.out.println("\t\t\t2 查 找 房 屋");
                System.out.println("\t\t\t3 删 除 房 屋 信 息");
                System.out.println("\t\t\t4 修 改 房 屋 信 息");
                System.out.println("\t\t\t5 房 屋 列 表");
                System.out.println("\t\t\t6 退       出");
                System.out.println("请输入你的选择（1-6）:");
                key = Utility.readChar();
                switch(key){
                    case '1':
                        addHouse();
                        break;
                    case '2':
                        findHouse();
                        break;
                    case '3':
                        delHouse();
                        break;
                    case '4':
                        System.out.println("修改");
                        break;
                    case '5':
                        listHouse();
                        break;
                    case '6':
                        exit();
                        break;
                }
    
            }while(loop);
        }
    }

（7）完成修改房屋信息的功能：（最终代码）

package houseserent.view;
    
    import houseserent.domain.House;
    import houseserent.service.HouseService;
    import houseserent.utils.Utility;
    import jdk.jshell.execution.Util;
    
    public class HouseView {
        private boolean loop=true;//控制显示菜单
        private char key=' ';//接收用户选择
        private HouseService houseService=new HouseService(10);
        public void update(){
            System.out.println("----------修改房屋信息---------");
            System.out.println("请选择待修改房屋编号（-1表示退出）：");
            int updateId=Utility.readInt();
            if(updateId==-1){
                System.out.println("----------你放弃修改房屋信息---------");
                return ;
            }
    
            //返回的是引用类型，即数组的元素
            //所以后面对house.setXxx()，就会修改HouseService中数组的元素
            House house=houseService.findById(updateId);
            if(house==null){
                System.out.println("----------修改房屋信息编号不存在---------");
                return ;
            }
            System.out.print("姓名（"+house.getName()+"）：");
            String name=Utility.readString(8,"");//如果用户直接回车表示不修改该信息，默认""
            if(!"".equals(name)){
                house.setName(name);
            }
            System.out.println("电话（"+house.getPhone()+"）：");
            String phone=Utility.readString(12,"");
            if(!"".equals(phone)){
                house.setPhone(phone);
            }
            System.out.println("地址（"+house.getAddress()+"）：");
            String address=Utility.readString(18,"");
            if(!"".equals(address)){
                house.setAddress(address);
            }
            System.out.println("租金（"+house.getRent()+"）：");
            int rent=Utility.readInt(-1);
            if(rent != (-1)){
                house.setRent(rent);
            }
            System.out.println("状态（"+house.getPhone()+"）：");
            String state=Utility.readString(3,"");
            if(!"".equals(state)){
                house.setState(state);
            }
            System.out.println("----------修改房屋信息成功---------");
        }
        public void findHouse(){//根据id查找房屋信息
            System.out.println("------------查找房屋信息--------------");
            System.out.println("请输入要查找的id：");
            int findId=Utility.readInt();
            House house=houseService.findById(findId);
            if(house!=null){
                System.out.println(house);
            }else{
                System.out.println("-----------查找的房屋信息id不存在-----------");
            }
        }
        public void exit(){//退出确认
            char c=Utility.readConfirmSelection();
            if(c=='Y'){
                loop=false;
            }
        }
        public void delHouse(){
            System.out.println("--------------删除房屋信息-------------");
            System.out.print("请输入待删除房屋的编号（-1退出）：");
            int delId=Utility.readInt();
            if(delId==-1){
                System.out.println("--------------放弃删除房屋信息-------------");
                return;
            }
            char choice=Utility.readConfirmSelection();
            if(choice=='Y') {
                if (houseService.del(delId)) {
                    System.out.println("--------------删除房屋信息成功---------------");
                } else {
                    System.out.println("---------------房屋编号不存在，删除失败----------------");
                }
            }else{
                    System.out.println("-------------放弃删除房屋信息-----------------");
            }
            System.out.print("请确认是否删除（Y/N）小心选择：");
            //readConfirmSelection()这个方法本身就有循环判断的逻辑，必须输入Y/N，否则循环不结束
            choice=Utility.readConfirmSelection();//判断输入的是否是Y/N
            if(choice=='Y'){
    
            }else{
                System.out.println("--------------放弃删除房屋信息--------------");
            }
        }
        public void addHouse(){//接收输入，增加房屋信息
            System.out.println("--------------添加房屋------------");
            System.out.print("姓名：");
            String name= Utility.readString(8);
            System.out.print("电话：");
            String phone=Utility.readString(12);
            System.out.print("地址：");
            String address=Utility.readString(16);
            System.out.print("月租：");
            int rent=Utility.readInt();
            System.out.print("状态：");
            String state=Utility.readString(3);
            //创建一个新的House对象，但id是系统分配的
            House newHouse=new House(0,name,phone,address,rent,state);
            if(houseService.add(newHouse)){
                System.out.println("---------------添加房屋成功-------------");
            }else{
                System.out.println("---------------添加房屋失败-------------");
            }
        }
        public void listHouse(){//显示房屋列表
            System.out.println("-----------------房屋列表--------------");
            System.out.println("编号\t房主\t电话\t地址\t月租\t状态（未出租/已出租）");
            House[] houses=houseService.list();//得到所有房屋信息
            for(int i=0;i<houses.length;i++){
                if(houses[i]==null){//如果为null，就不用再显示了
                    break;
                }
                System.out.println(houses[i]);
            }
            System.out.println("--------------房屋列表显示完毕---------------");
        }
        public  void mainMenu(){//显示主菜单
            do{
                System.out.println("---------------房屋出租系统菜单----------------");
                System.out.println("\t\t\t1 新 增 房 源");
                System.out.println("\t\t\t2 查 找 房 屋");
                System.out.println("\t\t\t3 删 除 房 屋 信 息");
                System.out.println("\t\t\t4 修 改 房 屋 信 息");
                System.out.println("\t\t\t5 房 屋 列 表");
                System.out.println("\t\t\t6 退       出");
                System.out.println("请输入你的选择（1-6）:");
                key = Utility.readChar();
                switch(key){
                    case '1':
                        addHouse();
                        break;
                    case '2':
                        findHouse();
                        break;
                    case '3':
                        delHouse();
                        break;
                    case '4':
                        update();
                        break;
                    case '5':
                        listHouse();
                        break;
                    case '6':
                        exit();
                        break;
                }
    
            }while(loop);
        }
    }

package houseserent.service;
    
    import houseserent.domain.House;
    
    public class HouseService {
        private House[] houses;//保存House对象
        private int houseNums=1;//记录当前有多少个房屋信息
        private int idCounter=1;//记录的id增长到哪里
        public HouseService(int size){
            houses=new House[size];//当创建HouseService对象时，指定大小
            houses[0]=new House(1,"jack","112","海淀区",2000,"未出租");
        }
        public House findById(int findId){//返回House对象或者null
            for(int i=0;i<houseNums;i++){
                if(findId==houses[i].getId()){
                    return houses[i];
                }
            }
            return null;
        }
        public boolean del(int delId){//删除一个房屋信息
            //注意下标和房屋编号无关系
            int index=-1;
            for(int i=0;i<houseNums;i++){
                if(delId==houses[i].getId()){//要删除的房屋（if），是数组下标为i的元素
                    index=i;//用index记录i
                }
            }
            if(index==-1){//说明delId在数组中不存在
                return false;
            }
            for(int i=index;i<houseNums;i++){
                houses[i]=houses[i+1];
            }
            houses[--houseNums]=null;//删掉某个房屋信息后，后面的往前移，最后一个房屋信息置空
            return true;
        }
        public boolean add(House newHouse){//添加新对象
            //判断是否还可以继续添加
            if(houseNums==houses.length){
                System.out.println("数组已满，不能再添加了...");
                return false;
            }
            //把newHouse对象加入到数组
            houses[houseNums++]=newHouse;
            //设计一个id自增长机制，然后更新newHouse的id
            newHouse.setId(++idCounter);
            return true;
        }
        public House[] list(){
            return houses;
        }
    }

package houseserent;
    
    import houseserent.view.HouseView;
    
    public class HouseRentApp {
        public static void main(String[] args) {
            //创建HouseView对象，并且显示主菜单，是整个程序的入口
            new HouseView().mainMenu();
            //相当于：
            //HouseView p1=new HouseView();
            //p1.mainMenu();
            System.out.println("--------你退出了房屋出租系统--------");
        }
    }

package houseserent.utils;
    
    /**
     工具类的作用:
     处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
     */
    
    import java.util.*;
    /**
     */
    public class Utility {
        //静态属性。。。
        private static Scanner scanner = new Scanner(System.in);
    
    
        /**
         * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
         * @return 1——5
         */
        public static char readMenuSelection() {
            char c;
            for (; ; ) {
                String str = readKeyBoard(1, false);//包含一个字符的字符串
                c = str.charAt(0);//将字符串转换成字符char类型
                if (c != '1' && c != '2' &&
                        c != '3' && c != '4' && c != '5') {
                    System.out.print("选择错误，请重新输入：");
                } else break;
            }
            return c;
        }
    
        /**
         * 功能：读取键盘输入的一个字符
         * @return 一个字符
         */
        public static char readChar() {
            String str = readKeyBoard(1, false);//就是一个字符
            return str.charAt(0);
        }
        /**
         * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
         * @param defaultValue 指定的默认值
         * @return 默认值或输入的字符
         */
    
        public static char readChar(char defaultValue) {
            String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
            return (str.length() == 0) ? defaultValue : str.charAt(0);
        }
    
        /**
         * 功能：读取键盘输入的整型，长度小于2位
         * @return 整数
         */
        public static int readInt() {
            int n;
            for (; ; ) {
                String str = readKeyBoard(10, false);//一个整数，长度<=10位
                try {
                    n = Integer.parseInt(str);//将字符串转换成整数
                    break;
                } catch (NumberFormatException e) {
                    System.out.print("数字输入错误，请重新输入：");
                }
            }
            return n;
        }
        /**
         * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
         * @param defaultValue 指定的默认值
         * @return 整数或默认值
         */
        public static int readInt(int defaultValue) {
            int n;
            for (; ; ) {
                String str = readKeyBoard(10, true);
                if (str.equals("")) {
                    return defaultValue;
                }
    
                //异常处理...
                try {
                    n = Integer.parseInt(str);
                    break;
                } catch (NumberFormatException e) {
                    System.out.print("数字输入错误，请重新输入：");
                }
            }
            return n;
        }
    
        /**
         * 功能：读取键盘输入的指定长度的字符串
         * @param limit 限制的长度
         * @return 指定长度的字符串
         */
    
        public static String readString(int limit) {
            return readKeyBoard(limit, false);
        }
    
        /**
         * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
         * @param limit 限制的长度
         * @param defaultValue 指定的默认值
         * @return 指定长度的字符串
         */
    
        public static String readString(int limit, String defaultValue) {
            String str = readKeyBoard(limit, true);
            return str.equals("")? defaultValue : str;
        }
    
    
        /**
         * 功能：读取键盘输入的确认选项，Y或N
         * 将小的功能，封装到一个方法中.
         * @return Y或N
         */
        public static char readConfirmSelection() {
            System.out.println("请输入你的选择(Y/N): 请小心选择");
            char c;
            for (; ; ) {//无限循环
                //在这里，将接受到字符，转成了大写字母
                //y => Y n=>N
                String str = readKeyBoard(1, false).toUpperCase();
                c = str.charAt(0);
                if (c == 'Y' || c == 'N') {
                    break;
                } else {
                    System.out.print("选择错误，请重新输入：");
                }
            }
            return c;
        }
    
        /**
         * 功能： 读取一个字符串
         * @param limit 读取的长度
         * @param blankReturn 如果为true ,表示 可以读空字符串。
         * 					  如果为false表示 不能读空字符串。
         *
         *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
         * @return
         */
        private static String readKeyBoard(int limit, boolean blankReturn) {
    
            //定义了字符串
            String line = "";
    
            //scanner.hasNextLine() 判断有没有下一行
            while (scanner.hasNextLine()) {
                line = scanner.nextLine();//读取这一行
    
                //如果line.length=0, 即用户没有输入任何内容，直接回车
                if (line.length() == 0) {
                    if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                    else continue; //如果blankReturn=false,不接受空串，必须输入内容
                }
    
                //如果用户输入的内容大于了 limit，就提示重写输入
                //如果用户如的内容 >0 <= limit ,我就接受
                if (line.length() < 1 || line.length() > limit) {
                    System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                    continue;
                }
                break;
            }
    
            return line;
        }
    }

[40aa2c6c4ad94ee3b462429ae160d036.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3e901c847b0c41a0bce9c146ed0680db.png
[ef2d8927bf2b44548e105e9238d16ebe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/02bfd09d690c4f54874a83d61168e02c.png
[85ffb390ef9d44288834e3412aa81f8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3be18215bebb4b6ba195d90ec7b6f43e.png
[cdf339752c5e461c8446535bf5f1e02f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/587ecd17aa6848b9b320317c49d6c8a7.png
[5ce780e9e4cf4093b4b7b2d2dc9b5c7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d8c4c6c76fb54405beb69da2d54714aa.png
[90f4d315f88d4ca98c457f6cc6e57349.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7eea9513397d4b47baf7fc4d5af8b28a.png
[68a8efe1c9434e5cb2720b58c76c562a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c04f966713bf4eaf92ccd2d000dbb935.png
[f5575281acb647acb54f4703301232f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3dd9ed5892ff4d6089de7336b1e1f9fe.png
[127cdef60ac94c1fa0052147de05abe2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ec8544f81f1540a58d0eb93518d5f138.png