OOP第一次博客作业
一. 前言
在过去三周里每周都有一次PTA大作业，每次的内容都是在前一次的内容上更加复杂，也更完善。这几次作业考察的不只是基础的Java语法，还有正则表达式，动态列表等，更注重语句之间的逻辑性。从前几次简单的程序要求一下跳到这么困难的题，让人有点难以适应。特别是不定数量，不定顺序的代码提取让人摸不着头脑，呜呼难哉！
二. 设计与分析
- 第一次判题程序
第一次判题程序只要求模拟一个小型的测试，只有一张试卷，也只面向一个学生，比起后面两题还算简单。但是这时我对正则只有一个囫囵的概念，碰到时请教AI较多。为了这次的题目不得不仔细学习了一番，花了好多时间（结果还是不太会，依旧错误频出ಥ⌣ಥ）。
程序的输入信息分三部分：题目数量、题目内容和答题信息
1.题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2.题目内容
一行为一道题，可以输入多行数据。
格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
样例：#N:1 #Q:1+1= #A:2
3.答题信息
答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。
格式："#A:"+答案内容
格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。
样例：#A:2 #A:78
程序的输出信息也分三部分：题目数量、答题信息和判断信息
1.题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2.答题信息
一行为一道题的答题信息，根据题目的数量输出多行数据。
格式：题目内容+" ~"+答案
样例：1+1=~2
2+2= ~4
3.判题信息
判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。
格式：判题结果+" "+判题结果
格式约束：
1、判题结果输出只能是true或者false，
2、判题信息的顺序与输入答题信息中的顺序相同
样例：true false true
下面是类图
可以看到整体还是比较复杂的，特别是对一个刚接触Java不久的菜鸟来说。而且类与类之间层层关联，稍有不慎就会影响全局。(┳Д┳)
import java.util.*;
class Question
{
private int number;
private String content;
private String standardAnswer;
public Question(int number,String content,String standardAnswer)
{
this.number=number;
this.content=content;
this.standardAnswer=standardAnswer;
}
public boolean judge(String answer)
{
boolean p=true;
if(this.standardAnswer!=answer)
p=false;
return p;
}
public String getContent()
{
return content;
}
public int getNumber()
{
return number;
}
}
class TestPaper
{
private Map<Integer,Question>questions=new TreeMap<>();
public void addQuestion(int num,String question,String answer)
{
questions.put(num,new Question(num,question,answer));
}
public boolean judge(int num,String answer)
{
if (questions.containsKey(num))
{
return questions.get(num).judge(answer);
}
return false;
}
public Collection<Question>getQuestions()
{
return questions.values();
}
}
class AnswerSheet
{
private TestPaper testPaper;
private Map<Integer,String>answers=new LinkedHashMap<>();
private List<Boolean>results=new ArrayList<>();
public AnswerSheet(TestPaper testPaper)
{
this.testPaper=testPaper;
}
public void addAnswer(int num,String answer)
{
answers.put(num,answer);
results.add(testPaper.judge(num,answer));
}
public void printResults()
{
int i=0;
for(Question q:testPaper.getQuestions())
{
System.out.println(q.getContent()+"~"+answers.get(q.getNumber()));
}
for(boolean result:results)
{
if(i==0)
{
System.out.print("true");
i++;
}
else
System.out.print(" "+"true");
}
}
}
public class Main
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
TestPaper testPaper=new TestPaper();
int numberOfQuestions=Integer.parseInt(input.nextLine().trim());
for(int i=0;i<numberOfQuestions;i++)
{
String []parts=input.nextLine().trim().split(" ");
int number=Integer.parseInt(parts[0].split(":")[1]);
String question=parts[1].split(":")[1];
String answer=parts[2].split(":")[1];
testPaper.addQuestion(number,question,answer);
}
AnswerSheet answerSheet=new AnswerSheet(testPaper);
while(input.hasNextLine())
{
String line=input.nextLine().trim();
if (line.equalsIgnoreCase("end"))
{
break;
}
String[]answerParts=line.split(" ");
for (int i=0;i<answerParts.length;i++)
{
int num=i+1;
String answer=answerParts[i].split(":")[1];
answerSheet.addAnswer(num,answer);
}
}
answerSheet.printResults();
}
}
最终代码就是长这样，可以看到其实复杂的部分在main里，其他的类主要是相互之间的配合调动，特别是判断程序一层一层的调动，感觉很复杂，其实也不简单。(ﾉ*ﾟｰﾟ)ﾉ
- 第二次判题程序
这次的环境模拟比起第一次要复杂的多，要求我们要对多张试卷、多张答卷进行信息处理。判题部分也不止是要求对答题正误的判断，还要判断每张试卷的分值是否为100分以及答案信息是否等于试卷的题目数量，并且三种信息可能会打乱顺序混合输入，编译难度提升了不止一个level。
程序输入信息分三种，三种信息可能会打乱顺序混合输入：
1.题目信息
一行为一道题，可输入多行数据（多道题）。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
2.试卷信息
一行为一张试卷，可输入多行数据（多张卷）。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2
3.答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。
格式："#S:"+试卷号+" "+"#A:"+答案内容
格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
22是1号试卷的顺序第2题的题目答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
程序输出格式:
1.试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2.答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：
3+2=5true
4+6=22false.
answer is null
3.判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
没有输入答案的题目计0分
判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”
下面是类图
可以看到不管是题目长度还是类图复杂度都比第一次难了不止一星半点。
import java.util.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
class Question
{
private int number;
private String content;
private String standardAnswer;
public Question(int number,String content,String standardAnswer)
{
this.number=number;
this.content=content;
this.standardAnswer=standardAnswer;
}
public boolean judge(String answer)
{
boolean p=true;
if(this.standardAnswer!=answer)
p=false;
return p;
}
public String getContent()
{
return content;
}
public int getNumber()
{
return number;
}
}
class TestPaper
{
private List<Question> questions;
public TestPaper()
{
questions=new ArrayList<>();//初始化List
}
//添加题目
public void addQuestion(int number,String content,String answer)
{
Question q=new Question(number,content,answer);
questions.add(q);
}
//获取题目列表的方法
public List<Question> getQuestions()
{
return questions;
}//判断
public boolean judge(int number,String answer)
{
for(Question q:questions)
{
if(q.getNumber()==number)
{
return q.judge(answer);
}
}
return false;
}
}
class AnswerSheet
{
private TestPaper testPaper;
private List<String> answers=new ArrayList<>();
private List<Boolean>results=new ArrayList<>();
public AnswerSheet(TestPaper testPaper)
{
this.testPaper=testPaper;
}
public void addAnswer(int num,String answer)
{
answers.add(num,answer);
results.add(testPaper.judge(num,answer));
}
public void printResults()
{
int i=0;
for(Question q:testPaper.getQuestions())
{
System.out.print(q.getContent()+"~"+answers.get(q.getNumber())+"~");
}
for(boolean result:results)
{
System.out.println(result);
}
}
}
public class Main
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
List<String> standardAnswers=new ArrayList<>();
List<String> questions=new ArrayList<>();
List<String> answers=new ArrayList<>();
List<String> scores=new ArrayList<>();
String s1=input.nextLine();
String s2=input.nextLine();
String s3=input.nextLine();
String s4=input.nextLine();
String s5=input.nextLine();
String regexStr1="#N:(\\s*[1-9]\\d*\\s*) #Q:(.*) #A:(.*)";
String regexStr2="#T:(\\s*[1-9]\\d*\\s*) 1-(.*) 2-(.*)";
String regexStr3="#S:(\\s*[1-9]\\d*\\s*) #A:(.*) #A:(.*)";
Pattern pattern1=Pattern.compile(regexStr1);
Matcher matcher1=pattern1.matcher(s1);
while(matcher1.find())
{
String a=matcher1.group(1);
String b=matcher1.group(2);
questions.add(b);
String c=matcher1.group(3);
standardAnswers.add(c);
}
Pattern pattern2=Pattern.compile(regexStr1);
Matcher matcher2=pattern2.matcher(s2);
while(matcher2.find())
{
String a=matcher2.group(1);
String b=matcher2.group(2);
questions.add(b);
String c=matcher2.group(3);
standardAnswers.add(c);
}
Pattern pattern3=Pattern.compile(regexStr2);
Matcher matcher3=pattern3.matcher(s3);
while(matcher3.find())
{
String a=matcher3.group(1);
String b=matcher3.group(2);
scores.add(b);
String c=matcher3.group(3);
scores.add(c);
}
Pattern pattern4=Pattern.compile(regexStr3);
Matcher matcher4=pattern4.matcher(s4);
while(matcher4.find())
{
String a=matcher4.group(1);
String b=matcher4.group(2);
answers.add(b);
String c=matcher4.group(3);
answers.add(c);
}
int x=Integer.valueOf(scores.get(0)).intValue();
int y=Integer.valueOf(scores.get(1)).intValue();
int sum=0;
int o1=0;
int o2=0;
if((x+y)!=100)
System.out.println("alert: full score of test paper1 is not 100 points");
System.out.print(questions.get(0)+"~"+answers.get(0)+"~");
System.out.println(answers.get(0).equals(standardAnswers.get(0)));
System.out.print(questions.get(1)+"~"+answers.get(1)+"~");
System.out.println(answers.get(1).equals(standardAnswers.get(1)));
if(answers.get(0).equals(standardAnswers.get(0)))
{
sum+=x;
o1=x;
}
if(answers.get(1).equals(standardAnswers.get(1)))
{
sum+=y;
o2=y;
}
System.out.println(sum+" "+o1+"~"+o2);
}
}
代码如上。
错误心得
刚开始无论如何也没办法输出试卷是否为100分的提示，调试了很久也没有办法，还是请教了大佬才知道while(matcher.find())里的输出没有作用（果然只靠自己是没办法成功的，该问还得问“ψ(｀∇´)ψ）。改了之后又有了新的问题，那就是我的判断语句根本没办法运行，刚开始还以为是逻辑问题，一直等到老师上课讲到正则这一部分才知道原来还是while(matcher.find())的问题，在他里面定义的变量除了循环后是用不了的！！害人不浅的while(matcher.find())。
其次就是问题和答案的输入，由于第一题先入为主，再加上题目太长没有看仔细（其实是我自己太懒╥﹏╥），我以为第二题的题目和答案也是统一的。于是写正则表达式的时候还和第一题一样，结果怎么也过不了。仔细一看才发现，原来是可以随便出题，随便答题的！！下次再也不会不仔细看题目了，因小失大实在是得不偿失。
- 第三次判题程序
第三次的题目我真是看一眼就眼花缭乱的程度，整个人都不好了。它在第二题的基础上还增加了学生信息。也就是说现在不止要判断多张试卷的分值，还要判断不同学生的不同题目的正误，最后再分别统计得分。不仅如此，它还要求可以删除题目，以及对多种异常输入的检测。
输入格式:
程序输入信息分五种，信息可能会打乱顺序混合输入。
1.题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2.试卷信息
试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2
3、学生信息
学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。
格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：
格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号
5.删除题目信息
删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+题目号
格式约束：
题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。
程序输出格式:
1.试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2.答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。
样例：
3+2=~5~true
4+6=~22~false.
answer is null
3.判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
被删除的题目提示信息
当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。
题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
4.格式错误提示信息
输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
例如：wrong format:2 #Q:2+2= #4
试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。
学号引用错误提示信息
如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。
下面是类图
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
class Student
{
String id;
String name;
public Student(String id, String name)
{
this.id=id;
this.name=name;
}
public String getStudent_id()
{
return id;
}
public void setId(String id)
{
this.id=id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
}
class Question
{
private int number;
private String content;
private String standardAnswer;
public Question(String number, String content, String standardAnswer)
{
this.number=number;
this.content=content;
this.standardAnswer=standardAnswer;
}
public boolean judge(String answer)
{
boolean p=false;
if(answer==this.standardAnswer)
p=true;
return p;
}
public String getNumber()
{
return number;
}
public void setNumber(String number)
{
this.number=number;
}
public String getContent()
{
return content;
}
public void setContent(String content)
{
this.content=content;
}
public String getAnswer()
{
return standardAnswer;
}
public void setAnswer(String standardAnswer)
{
this.standardAnswer=standardAnswer;
}
}
class TestPaper
{
String number;
private Map<Integer,Question>questions=new TreeMap<>();
List<Question>question=new ArrayList<>();
public List<Question> getQuestion()
{
return question;
}
public void setQuestion(List<Question>question)
{
this.question=question;
}
public boolean judge(int num,String answer)
{
if (questions.containsKey(num))
{
return questions.get(num).judge(answer);
}
return false;
}
public TestPaper(String number)
{
this.number=number;
}
public void addQuestion(String questionNumber, int score)
{
questions.put(questionNumber, score);
}
public String getNumber()
{
return number;
}
public void setNumber(String number)
{
this.number=number;
}
public Map<String,Integer> getQuestions()
{
return questions;
}
public void setQuestions(Map<String,Integer>questions)
{
this.questions=questions;
}
}
class AnswerSheet
{
private String testPaperNumber;
private TestPaper testPaper;
private String id;
private Map<String,String>answers=new LinkedHashMap<>();
private List<Boolean>results=new ArrayList<>();
public AnswerSheet(String testPaperNumber,String id)
{
this.testPaperNumber=testPaperNumber;
this.id=id;
}
public AnswerSheet(String testPaperNumber,String id,TestPaper testPaper)
{
this.testPaperNumber=testPaperNumber;
this.id=id;
this.testPaper=testPaper;
}
public void addAnswer(String number,String answer)
{
answers.put(number,answer);
results.add(testPaper.judge(num,answer));
}
public void printResults()
{
int i=0;
for(Question q:testPaper.getQuestions())
{
System.out.println(q.getContent()+"~"+answers.get(q.getNumber()));
}
for(boolean result:results)
{
if(i==0)
{
System.out.print("true");
i++;
}
else
System.out.print(" "+"true");
}
}
public String getTestPaperNumber()
{
return testPaperNumber;
}
public void setTestPaperNumber(String testPaperNumber)
{
this.testPaperNumber = testPaperNumber;
}
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public Map<String, String> getAnswers()
{
return answers;
}
public void setAnswers(Map<String, String> answers)
{
this.answers = answers;
}
}
public class Main
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
String[]date=new String[20];
int []num=new int[20];
String []ques=new String[20];
String []an=new String[20];
int j=0;
int i=0,n=0;
date[0]=input.nextLine();
for(n=1;date[n]!="end";n++)
{
date[n]=input.nextLine();
}
String regex="#(N|T|X|S|D).*";
String regex1="#N:(\d+)\s+#Q:(.*?)\s+#A:(.*)";
String regex2="#T:(\d)\s+(.*)";
String regex3="#X:(\d{8}\s+[a-zA-Z]+)(-\d{8}\s+[a-zA-Z]+)*";
String regex4="#S:(\d) \d{8} (.*)";
String regex5="#D:N-(\d)";
Pattern pattern=Pattern.compile(regex);
for(i=0;i<n;i++)
{
Matcher matcher=pattern.matcher(date[1]);
if(matcher1.find())
{
String type=matcher.group(1);
switch(type)
{
case N:
{
pattern=Pattern.compile(regex1);
matcher=pattern.matcher(date[1]);
int a=Integer.parseInt(matcher1.group(1));
String b=matcher.group(2);
String c=matcher.group(3);
num[j]=a;
ques[j]=b;
an[j]=c;
j++;
};break;
case T:
{
pattern=Pattern.compile(regex2);
matcher=pattern.matcher(date[1]);
}
}
}
}
}
}
错误心得
第三次的错误真是数不胜数，首当其冲的依旧是正则表达式。最开始我写的是#Q(.)，但是他一直报错。AI告诉我要加上“？”，于是就变成了#Q(.？)，但是紧随其后的#A再加上？之后就开始报错，AI这时又说应该删去，真是让人摸不着头脑。╥﹏╥
刚开始我的想法是先把输入的字符串全部记录到一个数组里去，然后用正则判断第一个#后面的提示，再用对应的正则表达式提取。可是很快我就发现，我没办法确定每个字符group有多少，有时它只能接收到第一组和最后一组。所以我只能先判断他会有多少个输入，再提取。可是这就使代码的复用性变得很低。
三. 总结
三次的代码让我成长了很多。写代码最重要的是要先看清要求，然后才能去建构框架，把一个复杂的问题分成几个小部分会更简单。其次是考虑代码的复用性，尽量让代码简洁化。当然还要多问问题，不懂就要问，关门造车是行不通的。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~