PTA三次作业
  zPv2oYekCOgt 2024年04月22日 26 0

1.前言:
第一次作业难度较大,从无到有的设计,涉及到的主要类有Paper,Question,AnswerPaper,Main,主要题目方向为字符串判断与字符串处理(提取有效信息),判断对错算总分,配合一些Java自带的数据结构如ArrayList即可快速解决问题,第一次作业是后面作业的基础,需自行了解正则表达式等方法。第二次作业难度适中,题目在第一次作业前提下添加了试卷类,涉及较为复杂类引用,需要对类的引用有一定了解。第三次作业难度最高,在前两次作业基础上添加学生信息及删除题号,还添加了许多错误提醒及错误提醒优先级显示。这三次作业的难度可以说是逐次递增,需要学生在第一次作业建立良好的类结构,并在第二次作业中添加类,以及第三次作业给删除的题目添加标记以执行语句都是难点。这三次PTA作业考察了学生构建程序框架的能力,以及正则表达式提取所需信息,ArrayList储存内容等方面的知识。
2.设计与分析:
第一次作业:
只需用AnswerPaper判断,Paper储存Question数组。由于当时还未学习ArrayList,使用数组储存,设计上采用两个字符串数组,一个数组装题目(题号与题目对应),一个数组装写的答案(题号与标准的答案对应),传递到AnswerPaper中进行比较。Question类封装题目信息,包括题号、题目内容、标准答案、作答;最后再将Question类封装进AnswerPaper类,其方法为判断答案与标准答案是否相同,最后进行输出。
建立Question类储存数据

点击查看源码

class Question{
    private int num;
    private String content;
    private String standard_answer;
    private String answer;
    private boolean result;
    public Question(){}
    public Question(int num,String content,String standard_answer,String answer,boolean result){
        this.num=num;
        this.content=content;
        this.standard_answer=standard_answer;
        this.answer=answer;
        this.result=result;
    }
    public String getStandard_Answer(){
        return standard_answer;
    }
    public void setStandard_Answer(String standard_answer){
        this.standard_answer=standard_answer;
    }
    public String getContent(){
        return content;
    }
    public void setContent(String content){
        this.content=content;
    }
    public int getNum(){
        return num;
    }
    public void setNum(int num){
        this.num=num;
    }
    public void setAnswer(String answer){
        this.answer=answer;
    }
    public String getAnswer(){
        return answer;
    }
    public void setResult(boolean result){
        this.result=result;
    }
    public boolean getResult(){
        return this.result;
    }
    public boolean TF(){
        if(standard_answer==answer)
        {
            result=true;
        }
        else
        {
            result=false;
        }
        return result;
    }
}

建立AnswerPaper类以便判断
点击查看源码
class AnswerPaper{
    private Paper paper;
    private Question []question=new Question[1000];
    public AnswerPaper(Paper paper,String str,int num){
        this.paper=paper;
        String answer1;
        boolean result;
        String strs[]=str.split(" #");
        for(int i=0;i<strs.length;i++)
        {
            String strs1[]=strs[i].split(":");
            strs1[1]=strs1[1].trim();
            answer1=strs1[1];
            if(answer1.equals(this.paper.getQuestionAnswer(i+1)))
            {
                result=true;
            }
            else
            {
                result=false;
            }
            Question que=new Question(i+1,paper.getQuestionContent(i+1),paper.getQuestionAnswer(i+1),answer1,result);
            question[i]=que;
        }
    }
    public String getPaperAnswer(int i){
        return question[i-1].getAnswer();
    }
    public String getPaperResult(int a){
        String str=String.valueOf(question[0].getResult());
        for(int i=1;i<a;i++)
        {
            str=str+" "+String.valueOf(question[i].getResult());
        }
        return str;
    }
}
建立Paper类以储存Question数组,提取题目内容
点击查看源码
class Paper{
    private int num;
    private Question []question=new Question[1000];
    private int flag=1;
    public Paper(){}
    public Paper(int num){
        this.num=num;
    }
    public void setNum(int num){
        this.num=num;
    }
    public int getNum(){
        return num;
    }
    public void setQuestion(String str){
        String strs[]=str.split(" #");
        String strs1[]=strs[0].split(":");
        strs1[1]=strs1[1].replaceAll(" ","");
        int i=Integer.parseInt(strs1[1]);
        String strs2[]=strs[1].split(":");
        strs2[1]=strs2[1].trim();
        String strs3[]=strs[2].split(":");
        strs3[1]=strs3[1].replaceAll(" ","");
        Question que=new Question(i,strs2[1],strs3[1],null,true);
        question[i-1]=que;
    }
    public String getQuestionAnswer(int i){
        return question[i-1].getStandard_Answer();
    }
    public String getQuestionContent(int i){
        return question[i-1].getContent();
    }
}
SourceMontor的生成报表如下

类图如下

第二次作业:
第二次作业在第一次作业的基础上增加了试卷和答卷,其中试卷中包括题目的序号以及分值。试卷中极有可能有多道题,这就导致可能会出现答案不全的情况(试卷中的题目并没有全都被作答)。在输出部分,第二次作业比第一次作业多了试卷满分不是100分、答卷缺失部分答案、无效的试卷号。在输入格式方面,第二次作业的格式与第一次作业的格式要求没有变化,因为没有错误要求,所以输入的都为正确格式,正则表达式的作用也只是将输入的字符串分成几个部分。此次作业使用了类,但是并没有遵守或运用单一职责原则、开闭原则、迪米特法则,且许多判定过程写在了主方法中,而不是写在类中作为类的方法,更没有代理类。因为在敲之前,很多逻辑部分并没有思考清楚,导致代码出现了许多的冗余及不必要的代码,但又担心删掉那部分之后代码无法正常运行,所以为了完成作业得到较高的分数就没有修改。这次作业中,我深刻意识到了写注释的重要性。前几次提交之后,我发现代码的逻辑有些问题。但当我回头看我的代码的时候,我已经看不懂我原来的写的内容了。一方面是因为,代码更多的是面向过程而非面向对象,另一方面就是因为没有写注释了。写注释不仅有益于在写代码过程中清晰自己的逻辑,更有益于改代码过程中读懂自己之前写的代码。

SourceMontor的生成报表如下:

可见代码存在许多的不足(方法的功能较为单一、最复杂方法行的数量过高有待优化、代码中的块结构相对简单、注释少等),大多是由于基础知识不扎实,但第二次作业是在第一次作业基础上完成的,难度有所降低。在第一次作业基础上,我将提取有效内容功能放在了main中,用上了ArrayList传递数据,将作答部分写成新类——Answer——代码如下:

点击查看代码
class Answer{
    private String answer;
    private int grade;
    public Answer(String answer){
        this.answer=answer;
    }

    public String getAnswer(){
        return answer;
    }

    public void setGrade(int grade){
        this.grade=grade;
    }
    public int getGrade(){
        return grade;
    }
}
在Paper类中添加分数数组以求试卷总分——代码如下:
点击查看代码
class Paper{
    private int num;
    private int score_sum;
    private int question_sum;
    private ArrayList<Question> list = new ArrayList<>();
    private int score[];
    public Paper(int num,int questionnum[],int score[],ArrayList<Question> listQuestion)
    {
        this.num=num;
        this.score=score;
        this.question_sum=questionnum.length-1;
        for(int i=1;i<score.length;i++)
        {
            this.score_sum+=this.score[i];
        }
        for(int i=1;i<questionnum.length;i++)
        {
            for(Question t:listQuestion)
            {
                if(questionnum[i]==t.getNum())
                {
                    list.add(t);
                }
            }
        }
    }

    public ArrayList<Question> getList(){
        return list;
    }

    public int getSum()
    {
        return score_sum;
    }

    public int getNum(){
        return num;
    }

    public int getScore(int i){
        return score[i+1];
    }
}
减少了AnswerPaper功能,使该类的功能更明显,更多在Main中实现——代码如下:
点击查看代码
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Question> listQuestion = new ArrayList<>();
        ArrayList<Paper> listPaper = new ArrayList<>();
        ArrayList<AnswerPaper> listAnswerPaper = new ArrayList<>();
        String str=scanner.nextLine();
        while(!str.equals("end"))
        {
            if(str.indexOf("#N")!=-1)
            {
                String strs[]=str.split(" #");
                String strs1[]=strs[0].split(":");
                strs1[1]=strs1[1].replaceAll(" ","");
                int i=Integer.parseInt(strs1[1]);
                String strs2[]=strs[1].split(":");
                strs2[1]=strs2[1].trim();
                String strs3[]=strs[2].split(":");
                strs3[1]=strs3[1].replaceAll(" ","");
                Question question=new Question(i,strs2[1],strs3[1]);
                listQuestion.add(question);
            }
            if(str.indexOf("#T")!=-1)
            {
                String strs[]=str.split(" ");
                String strs1[]=strs[0].split(":");
                int questionnum[]=new int [strs.length];
                int score[]=new int [strs.length];
                int i=Integer.parseInt(strs1[1]);
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    questionnum[j]=Integer.parseInt(strs2[0]);
                    score[j]=Integer.parseInt(strs2[1]);
                }
                Paper paper=new Paper(i,questionnum,score,listQuestion);
                listPaper.add(paper);
            }
            if(str.indexOf("#S")!=-1)
            {
                ArrayList<Answer> listAnswer = new ArrayList<>();
                String strs[]=str.split(" #");
                String strs1[]=strs[0].split(":");
                strs1[1]=strs1[1].replaceAll(" ","");
                int i=Integer.parseInt(strs1[1]);
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split(":");
                    Answer answer=new Answer(strs2[1]);
                    listAnswer.add(answer);
                }
                AnswerPaper answerPaper=new AnswerPaper(i,listAnswer);
                listAnswerPaper.add(answerPaper);
            }
            str=scanner.nextLine();
        }
        for (int i = 0; i < listPaper.size(); i++) {
            if(listPaper.get(i).getSum()!=100)
            {
                System.out.println("alert: full score of test paper"+listPaper.get(i).getNum()+" is not 100 points");
            }
        }
        int flag=1;
        for(AnswerPaper r : listAnswerPaper)
        {
            flag=1;
            for (Paper p:listPaper) 
            {
                if(r.getNum()==p.getNum())
                {
                    flag=0;
                    for(int i = 0; i < p.getList().size()&& i < r.getList().size(); i++)
                    {
                        Question w=p.getList().get(i);
                        Answer x=r.getList().get(i);
                        System.out.print(w.getContent()+"~"+x.getAnswer()+"~");
                        if(w.getStandard_Answer().equals(x.getAnswer()))
                        {
                            System.out.println("true");
                            x.setGrade(p.getScore(i));
                            r.setSum(p.getScore(i));
                        }
                        else
                        {
                            System.out.println("false");
                            x.setGrade(0);
                        }
                    }
                    for(int i = 0; i < p.getList().size() - r.getList().size(); i++)
                    {
                        System.out.println("answer is null");
                    }
                    for(int i = 0; i < p.getList().size(); i++)
                    {
                        if(i < r.getList().size())
                        {
                            Answer x=r.getList().get(i);
                            System.out.print(x.getGrade());
                        }
                        else
                            System.out.print("0");
                        if(i!=p.getList().size()-1)
                            System.out.print(" ");
                        else
                            System.out.print("~");
                    }
                    System.out.println(r.getSum());
                }
            }
        }
        if(flag==1)
            System.out.println("The test paper number does not exist");
    }
}
class AnswerPaper{
    private int num;
    private int sum;
    private ArrayList<Answer> list = new ArrayList<>();
    public AnswerPaper(int num,ArrayList<Answer> listAnswer){
        this.num=num;
        for(Answer t:listAnswer)
        {
            list.add(t);
        }
    }

    public int getNum(){
        return num;
    }

    public ArrayList<Answer> getList(){
        return list;
    }

    public void setSum(int grade){
        this.sum+=grade;
    }

    public int getSum(){
        return sum;
    }
}
Question类用于储存数据,基本不变,减少了未使用的get/set方法,简化代码——代码如下:
点击查看代码
class Question{
    private int num;
    private String content;
    private String standard_answer;

    public Question(int num,String content,String standard_answer){
        this.num=num;
        this.content=content;
        this.standard_answer=standard_answer;
    }

    public int getNum(){
        return num;
    }

    public String getContent(){
        return content;
    }

    public String getStandard_Answer(){
        return standard_answer;
    }
}

类图如下:

第三次作业:
第三次作业结束了几天,至今仍有心理阴影,心理路程依旧记忆犹新,不仅是正则表达式学习实践每每出错,难以改正,split的使用出现非零返回,耗费心力,而且删减的过程也是困难重重(会在采坑心得内分析),我的得分很低,该代码多用于避坑,辩证性看待分析。
第三次作业在第二次作业的基础上增加了删除题目和学生信息,这就使在输出部分多了找不到学生信息以及题目被删出,另外,作业中还增加了引用本来就不存在的题目等错误情况,并要求错误优先级显示。这次作业我做出了一部分改进,使代码变得复杂度降低一些,且开始有意识的遵循或运用单一职责原则、开闭原则、迪米特法则。

  第三次作业增加了错误格式这一部分。我便没有办法像前两次作业一样只用split切割输入语句,增加了Matcher和Pattern的运用。在运用错误格式这里,我卡了很久,卡的测试点中错误表达式就占了两种类型(8个点)。重写了很久pattern.compile和输入部分的代码,后尝试改回split,但效果不佳。感觉不是什么技术问题、逻辑问题、理解问题或者设计问题,可能是做事不够仔细认真,对正则表达式理解不够彻底。

  第三次作业增加了Student类——代码如下:
点击查看代码
class Student{
    private String num;
    private String name;
    public Student(String num,String name){
        this.num=num;
        this.name=name;
    }
    public String getNum(){
        return num;
    }
    public String getName(){
        return name;
    }
}
用作链表的类储存数据。尝试在Paper类中添加判断题目序号有效与否——代码如下:
点击查看代码
class Paper{
    private int num;
    private int score_sum;
    private int question_sum;
    private ArrayList<Question> list = new ArrayList<>();
    private int score[];
    private boolean haveque=true;
    public Paper(int num,int questionnum[],int score[],ArrayList<Question> listQuestion)
    {
        this.num=num;
        this.score=score;
        this.question_sum=questionnum.length-1;
        for(int i=1;i<score.length;i++)
        {
            this.score_sum+=this.score[i];
        }
        for(int i=1;i<questionnum.length;i++)
        {
            
            for(Question t:listQuestion)
            {
                if(questionnum[i]==t.getNum())
                {
                    list.add(t);
                    this.haveque=true;
                }
                else
                {
                    this.haveque=false;
                }
            }
        }
    }

    public ArrayList<Question> getList(){
        return list;
    }

    public int getSum()
    {
        return score_sum;
    }
    public boolean getHaveque()
    {
        return haveque;
    }
    public int getNum(){
        return num;
    }

    public int getScore(int i){
        return score[i+1];
    }
}
同时在Main中输出是添加判断条件——代码如下:
点击查看代码
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Question> listQuestion = new ArrayList<>();
        ArrayList<Student> listStudent = new ArrayList<>();
        ArrayList<Paper> listPaper = new ArrayList<>();
        ArrayList<AnswerPaper> listAnswerPaper = new ArrayList<>();
        String str=scanner.nextLine();
        int num_of_cut=0;
        while(!str.equals("end"))
        {
            Pattern pattern = Pattern.compile("^#N:(.*)\\s#Q:(.*)\\s+#A:(.*)");
            Matcher matcher = pattern.matcher(str);
            Pattern pattern2 = Pattern.compile("^#T:(\\d+)(\\s+(\\d+-\\d+))*$");
            Matcher matcher2 = pattern2.matcher(str);
            Pattern pattern3 = Pattern.compile("^#S:(\\d+)\\s+(\\d+)(.*)");
            Matcher matcher3 = pattern3.matcher(str);
            Pattern pattern4 = Pattern.compile("^#X:(\\d+)\\s+(\\w+)(-\\d+\\s\\w+)*$");
            Matcher matcher4 = pattern4.matcher(str);
            Pattern pattern5 = Pattern.compile("^#D:N\\-(\\d+)$");
            Matcher matcher5 = pattern5.matcher(str);
            
            if(matcher.find())
            {
                String num=matcher.group(1);
                String que=matcher.group(2);
                String ans=matcher.group(3);
                int i=Integer.parseInt(num);
                Question question=new Question(i,que,ans);
                listQuestion.add(question);
                
            }
            else if(matcher2.find())
            {
                String num=matcher2.group(1);
                String text=matcher2.group(2);
                String strs[]=text.split("\\s+");
                int numofp=Integer.parseInt(num);
                int questionnum[]=new int [strs.length];
                int score[]=new int [strs.length];
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    questionnum[j]=Integer.parseInt(strs2[0]);
                    score[j]=Integer.parseInt(strs2[1]);
                }
                Paper paper=new Paper(numofp,questionnum,score,listQuestion);
                listPaper.add(paper);
            }
            else if(matcher3.find())
            {
                ArrayList<Answer> listAnswer = new ArrayList<>();
                String num=matcher3.group(1);
                String nums=matcher3.group(2);
                String text=matcher3.group(3);
                String strs[]=text.split("\\s+#A:");
                int numofap=Integer.parseInt(num); 
                for(int j=1;j<strs.length;j++)
                {
                    String strs2[]=strs[j].split("-");
                    int num_of_que=Integer.parseInt(strs2[0]);
                    Answer answer=new Answer(num_of_que,strs2[1]);
                    listAnswer.add(answer);
                }
                AnswerPaper answerPaper=new AnswerPaper(numofap,nums,listAnswer);
                listAnswerPaper.add(answerPaper);
            }
            else if(matcher4.find())
            {
                String text1=matcher4.group(1);
                String text=matcher4.group(2);
                Student student=new Student(text1,text);
                listStudent.add(student);
                String text2=matcher4.group(3);
                if(text2!=null)
                {
                    String strs3[]=text2.split("-");
                    for (String part : strs3)
                    {
                        if (part.length() > 8)
                        {
                            String date = part.substring(0, 8);
                            String nameOrIdentifier = part.substring(8);
                            Student student2 = new Student(date, nameOrIdentifier);  
                            listStudent.add(student2);  
                        }
                    }
                }
            }
            else if(matcher5.find())
            {
                String num=matcher5.group(1);
                num_of_cut=Integer.parseInt(num);
            }
            else
            {
                System.out.println("wrong format:"+str);
            }
            str=scanner.nextLine();
        }
        for (int i = 0; i < listPaper.size(); i++) {
            if(listPaper.get(i).getSum()!=100)
            {
                System.out.println("alert: full score of test paper"+listPaper.get(i).getNum()+" is not 100 points");
            }
        }
        int flag=1;
        for(AnswerPaper r : listAnswerPaper)
        {
            flag=1;
            for (Paper p:listPaper) 
            {
                if(r.getNum()==p.getNum())
                {
                    flag=0;
                    for(int i = 0; i < p.getList().size()&& i < r.getList().size(); i++)
                    {
                        Question w=p.getList().get(i);
                        Answer x=r.getList().get(i);
                        if(w.getNum()==num_of_cut)
                        {
                            x.setGrade(0);
                            System.out.println("the question "+w.getNum()+" invalid~0");
                        }
                        else
                        {
                            if(p.getHaveque())
                            {
                                System.out.print(w.getContent()+"~"+x.getAnswer()+"~");
                                if(w.getStandard_Answer().equals(x.getAnswer()))
                                {
                                    System.out.println("true");
                                    x.setGrade(p.getScore(i));
                                    r.setSum(p.getScore(i));
                                }
                                else
                                {
                                    System.out.println("false");
                                    x.setGrade(0);
                                }
                            }
                            else
                            {
                                System.out.println("non-existent question~0");
                                x.setGrade(0);
                            }
                        }
                    }
                    for(int i = 0; i < p.getList().size() - r.getList().size(); i++)
                    {
                        System.out.println("answer is null");
                    }
                    int flag1=0;
                    for(int j = 0;j<listStudent.size();j++){
                        
                        if(r.getNums().equals(listStudent.get(j).getNum()))
                        {
                            System.out.print(r.getNums()+" "+listStudent.get(j).getName()+": ");
                            for(int i = 0; i < p.getList().size(); i++)
                            {
                                if(i < r.getList().size())
                                {
                                    Answer x=r.getList().get(i);
                                    System.out.print(x.getGrade());
                                }
                                else
                                    System.out.print("0");
                                if(i!=p.getList().size()-1)
                                    System.out.print(" ");
                                else
                                    System.out.print("~");
                            }
                            System.out.println(r.getSum());
                            flag1=1;
                            break;
                        }
                    }
                    if(flag1==0)
                    {
                        System.out.println(r.getNums()+" not found");
                    }
                }
            }
        }
        if(flag==1)
            System.out.println("The test paper number does not exist");
    }
}
其他类没有思路去修改 SourceMontor的生成报表如下:

根据此报表,以下是改进方向:

减少方法调用:方法调用可能会导致代码执行效率降低。尝试合并或简化方法调用,以减少方法的调用次数。
增加注释:注释严重不足,有很多的空间来添加注释,从而提高代码的可读性和维护性。
优化类和接口:确保类的结构和接口的设计是合理的。避免过度耦合,尽量保持类的独立性。
控制方法复杂度:平均每方法语句数过多,这可能表明某些方法过于复杂。尝试分解这些方法为更小的、更专注的部分。
管理块深度:最大块深度为太大,这可能会影响代码的性能。优化块结构,使其更加扁平化,以减少执行时间。

类图如下:

采坑心得:
第一次作业:在answer1.equals(this.paper.getQuestionAnswer(i+1))判断时用equals不要直接用=,用等号过不了;
如图:

              Question类可简化出Answer类;

第二次作业:提取时用正则表达式会更加方便快捷;
第三次作业:这段代码中,我将spilt改为固定数提取,因为我发现在测试用例中20201103 Tom-20201104 Jack-20201105 Www检测不出空格,应该是无空格,测试用例中的空格不存在。

点击查看代码
if(text2!=null)
                {
                    String strs3[]=text2.split("-");
                    for (String part : strs3)
                    {
                        if (part.length() > 8)
                        {
                            String date = part.substring(0, 8);
                            String nameOrIdentifier = part.substring(8);
                            Student student2 = new Student(date, nameOrIdentifier);  
                            listStudent.add(student2);  
                        }
                    }
                }
正则表达式中提取输入链表储存过程中提取会少数据,应该是Pattern.compile部分出错; 如图:

             试卷题目数明显少了。

改进建议:
第三次作业中,判定题目删减时用HashMap会好很多。
正则表达式的Pattern.compile有待改准。
第二次作业中,输入提取部分改用正则表达式提取。
写代码时提前画好类图以减少遗漏。

总结:
1.学到了:
Java是一门纯粹的面向对象语言,因此理解类、对象、继承、多态和封装这些OOP概念至关重要。这些概念是Java编程的核心。
理论知识很重要,但没有实践是不够的。尝试编写自己的程序,从简单的“Hello World”开始,逐步增加难度。通过实际编码,可以更好地理解概念,并学会如何解决问题。
Java拥有丰富的标准库,提供了许多预制的类和接口,用于处理文件、网络、数据库等。熟悉这些库可以节省编写代码的时间,并提高代码的质量。
编写清晰、可读的代码比仅仅让代码工作更重要。遵循良好的编码习惯,使用有意义的变量名和方法名,添加注释,这些都是编写可维护代码的关键。
Java中有许多提前设计好的便捷方法供我们使用,多学习有利于减少冗余代码,如:HashMap与ArrayList等。
2.需要进一步学习及研究:
在写代码之前,要将整个代码的逻辑部分设计好,避免出现写到中途手忙脚乱的现象。
提升代码的可复用性,注重设计中的开闭原则。
每次写完代码都会出现数组越界的情况,原因大概是思考逻辑时,无法面面俱到。多敲代码以提升自己的思考能力以及逻辑能力。画设计图、类图是个不错的选择。
对正则表达式理解、运用仍有不足。
3.建议:
希望老师能提前推荐更多用得上方法帮助作业完成。
希望测试点点明测试方向。
希望老师能演示类之间引用的例子,讲方法时更深入些,讲些多出现的特例。

【版权声明】本文内容来自摩杜云社区用户原创、第三方投稿、转载,内容版权归原作者所有。本网站的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@moduyun.com

  1. 分享:
最后一次编辑于 2024年04月22日 0

暂无评论

推荐阅读
zPv2oYekCOgt
作者其他文章 更多

2024-04-22