BLOG2
第四次大作业
7-3 答题判题程序-4
分数 82
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。本题在答题判题程序-3基础上新增的内容统一附加在输出格式说明之后，用粗体标明。
新增内容：
1、输入选择题题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#Z:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
新增约束：标准答案中如果包含多个正确答案（多选题），正确答案之间用英文空格分隔。
例如：
#Z:2 #Q:宋代书法有苏黄米蔡四家，分别是： #A:苏轼 黄庭坚 米芾 蔡襄
多选题输出：
输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。
多选题给分方式：
答案包含所有正确答案且不含错误答案给满分；包含一个错误答案或完全没有答案给0分；包含部分正确答案且不含错误答案给一半分，如果一半分值为小数，按截尾规则只保留整数部分。
例如：
#N:1 #Q:1+1= #A:2
#Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D
#T:1 1-5 2-9
#X:20201103 Tom
#S:1 20201103 #A:1-5 #A:2-A C
end
输出：
alert: full score of test paper1 is not 100 points
1+1=~5~false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
2、输入填空题题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#K:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
例如：#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
填空题输出：
输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。
填空题给分方式：
答案与标准答案内容完全匹配给满分，包含一个错误字符或完全没有答案给0分，包含部分正确答案且不含错误字符给一半分，如果一半分值为小数，按截尾规则只保留整数部分。
例如：
#N:1 #Q:1+1= #A:2
#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
#T:1 1-5 2-10
#X:20201103 Tom
#S:1 20201103 #A:1-5 #A:2-瑶琴
end
输出：
alert: full score of test paper1 is not 100 points
1+1=~5~false
古琴在古代被称为：~瑶琴~partially correct
20201103 Tom: 0 5~5
3、输出顺序变化
只要是正确格式的信息，可以以任意的先后顺序输入各类不同的信息。比如试卷可以出现在题目之前，删除题目的信息可以出现在题目之前等。
例如：
#T:1 1-5 2-10
#N:1 #Q:1+1= #A:2
#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
#X:20201103 Tom
#S:1 20201103 #A:1-5 #A:2-古筝
end
输出：
alert: full score of test paper1 is not 100 points
1+1=~5~false
古琴在古代被称为：~古筝~false
20201103 Tom: 0 0~0
4、多张试卷信息
本题考虑多个同学有多张不同试卷的答卷的情况。输出顺序优先级为学号、试卷号，按从小到大的顺序先按学号排序，再按试卷号。
例如：
#T:1 1-5 2-10
#T:2 1-8 2-21
#N:1 #Q:1+1= #A:2
#S:2 20201103 #A:1-2 #A:2-古筝
#S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴
#S:1 20201104 #A:1-2 #A:2-瑟
#S:2 20201104 #A:1-5 #A:2-七弦琴
#X:20201103 Tom-20201104 Jack
#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
end
输出：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=~5~false
古琴在古代被称为：~瑶琴或七弦琴~true
20201103 Tom: 0 10~10
1+1=~2~true
古琴在古代被称为：~古筝~false
20201103 Tom: 8 0~8
1+1=~2~true
古琴在古代被称为：~瑟~false
20201104 Jack: 5 0~5
1+1=~5~false
古琴在古代被称为：~七弦琴~partially correct
本次题目分析如下：
这个题目要求设计一个复杂的答题判题程序，能够处理多种输入信息，并根据这些信息进行判题和输出结果。程序需要考虑多种异常情况，如题目删除、题目引用错误、格式错误等，并根据不同的题目类型（选择题、填空题）进行不同的判分逻辑。
QuestionSet类
类名：QuestionSet
方法：
getNumber()：返回问题的编号。
getContent()：返回问题的内容。
getAnswerKey()：返回问题的答案关键信息。
isDeleted()：判断问题是否已被删除。
setDeleted(boolean deleted)：设置问题的删除状态。
QuestionBank
类名：QuestionBank
方法：
addQuestion(String input)：根据特定格式的输入添加普通问题到问题库。
addChoiceQuestion(String input)：根据特定格式的输入添加选择题到问题库。
addFillInBlankQuestion(String input)：根据特定格式的输入添加填空题到问题库。
getQuestionByNumber(int number)：根据问题编号获取对应的QuestionSet对象。
QuestionScore类
类名：QuestionScore
方法：
getNumber()：返回问题的编号。
getScore()：返回问题的分值。
TestPaper类
类名：TestPaper
方法：
setData(String input)：根据特定格式的输入设置试卷的相关数据，如编号和各题分值。
getNumber()：返回试卷的编号。
getQuestionScores()：返回试卷中各题分值的列表。
Student类
类名：Student
方法：
getId()：返回学生的学号。
getName()：返回学生的姓名。
TestPapersCollection类
类名：TestPapersCollection
方法：
addTestPaper(String input)：根据特定格式的输入添加试卷到试卷集合。
getPapers()：返回试卷集合中的所有试卷列表。
getTestPaperByNumber(int number)：根据试卷编号获取对应的TestPaper对象。
AnswerSheet类
类名：AnswerSheet
方法：
setData(String input)：根据特定格式的输入设置答题卡的相关数据，如试卷编号、学生学号和答案。
getPaperNumber()：返回答题卡对应的试卷编号。
getStudentId()：返回答题卡对应的学生学号。
getAnswers()：返回答题卡上的答案列表。
AnswerSheetsCollection类
类名：AnswerSheetsCollection
方法：
addAnswerSheet(String input)：根据特定格式的输入添加答题卡到答题卡集合。
getSheets()：返回答题卡集合中的所有答题卡列表。
Evaluation类
类名：Evaluation
方法：
processAnswerSheets(QuestionBank questionBank, TestPapersCollection testPapers, AnswerSheetsCollection answerSheets, Map<String, Student> studentMap)：处理答题卡集合，根据问题库、试卷集合和学生信息进行评分，并输出相关结果。
我觉得本题主要的难点就在于设计功能是对学生的答题情况进行评估和计分，并输出每个学生的成绩报告。这个类它接收QuestionBank、TestPapersCollection、AnswerSheetsCollection以及Map<String, Student>作为参数，通过遍历试卷、答题纸以及对应的问题和答案，根据设定的答案规则和分值来计算每个学生的得分，并展示详细的成绩信息。
以下是我的具体设计：
- 检查试卷总分是否为 100
点击查看代码
for (TestPaper paper : testPapers.getPapers()) {
int totalScore = paper.getQuestionScores().stream().mapToInt(QuestionScore::getScore).sum();
if (totalScore!= 100) {
System.out.println("alert: full score of test paper" + paper.getNumber() + " is not 100 points");
}
}
遍历TestPapersCollection中的每一份试卷。
通过stream和mapToInt操作对试卷中的每个QuestionScore对象获取分数并求和，得到该试卷的总分。
如果总分不等于 100，输出相应的警告信息，提示试卷总分不符合预期。
点击查看代码
answerSheets.getSheets().sort(Comparator.comparing(AnswerSheet::getStudentId).thenComparing(AnswerSheet::getCountryNumber));
获取AnswerSheetsCollection中的所有答题纸列表。
使用Comparator按照学生 ID 进行排序，如果学生 ID 相同，则按照试卷编号进一步排序。这样做可以使后续处理学生答题情况时按照一定顺序进行，便于输出整齐的成绩报告。
点击查看代码
for (AnswerSheet answerSheet : answerSheets.getSheets()) {
int score = 0;
StringBuilder scoreDetails = new StringBuilder();
// 获取对应试卷
TestPaper paper = testPapers.getTestPaperByNumber(answerSheet.getPaperNumber());
if (paper == null) {
System.out.println("The test paper number does not exist");
continue;
}
// 获取试卷的问题分数设置
List<QuestionScore> questions = paper.getQuestionScores();
for (int i = 0; i < questions.size(); i++) {
QuestionScore questionScore = questions.get(i);
String userAnswer = (i < answerSheet.getAnswers().size())? answerSheet.getAnswers().i:get(i) : null;
QuestionSet question = questionBank.getQuestionByNumber(questionScore.getNumber());
if (question!= null) {
// 处理已删除的问题
if (question.isDeleted()) {
System.out.println("the question " + questionScore.getNumber() + " invalid~0");
scoreDetails.append("0 ");
} else {
// 计分逻辑，根据问题类型和答案情况计分
String[] correctAnswers = question.getAnswerKey().split(" ");
List<String> userAnswers = Arrays.asList(userAnswer!= null? userAnswer.split(" ") : new String[0]);
// 处理多项选择题
if (correctAnswers.length > 1) {
boolean hasWrongAnswer = userAnswers.stream().anyMatch(ans ->!Arrays.asList(correctAnswers).contains(ans));
if (hasWrongAnswer) {
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~false");
scoreDetails.append("0 ");
} else {
boolean allCorrect = userAnswers.size() == correctAnswers.length &&
Arrays.asList(correctAnswers).containsAll(userAnswers);
if (allCorrect) {
score += questionScore.getScore();
scoreDetails.append(questionScore.getScore()).append(" ");
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~true");
} else {
int halfScore = questionScore.getScore() / 2;
score += halfScore;
scoreDetails.append(halfScore).append(" ");
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~partially correct");
}
}
} else { // 处理单项选择或填空题
if (userAnswer == null ||!userAnswer.trim().equals(question.getAnswerKey())) {
System.out.println(question.getContent() + "~" + (userAnswer!= null? userAnswer : "") + "~false");
scoreDetails.append("0 ");
} else {
score += questionScore.getScore();
scoreDetails.append(questionScore.getScore()).append(" ");
System.out.println(question.getContent() + "~" + userAnswer + "~true");
}
}
}
} else {
// 处理不存在的问题
System.out.println("non-existent question~0");
scoreDetails.append("0 ");
}
}
// 获取学生信息并输出成绩报告
Student student = studentMap.get(answerSheet.getStudentId());
if (student == null) {
System.out.println(answerSheet.getStudentId() + " not found");
} else {
System.out.printf("%s %s: %s~%d%n", student.getId(), student.getName(), scoreDetails.toString().trim(), score);
}
}
for (AnswerSheet answerSheet : answerSheets.getSheets()) {
int score = 0;
StringBuilder scoreDetails = new StringBuilder();
// 获取对应试卷
TestPaper paper = testPapers.getTestPaperByNumber(answerSheet.getPaperNumber());
if (paper == null) {
System.out.println("The test paper number does not exist");
continue;
}
// 获取试卷的问题分数设置
List<QuestionScore> questions = paper.getQuestionScores();
for (int i = 0; i < questions.size(); i++) {
QuestionScore questionScore = questions.get(i);
String userAnswer = (i < answerSheet.getAnswers().size())? answerSheet.getAnswers().i:get(i) : null;
QuestionSet question = questionBank.getQuestionByNumber(questionScore.getNumber());
if (question!= null) {
// 处理已删除的问题
if (question.isDeleted()) {
System.out.println("the question " + questionScore.getNumber() + " invalid~0");
scoreDetails.append("0 ");
} else {
// 计分逻辑，根据问题类型和答案情况计分
String[] correctAnswers = question.getAnswerKey().split(" ");
List<String> userAnswers = Arrays.asList(userAnswer!= null? userAnswer.split(" ") : new String[0]);
// 处理多项选择题
if (correctAnswers.length > 1) {
boolean hasWrongAnswer = userAnswers.stream().anyMatch(ans ->!Arrays.asList(correctAnswers).contains(ans));
if (hasWrongAnswer) {
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~false");
scoreDetails.append("0 ");
} else {
boolean allCorrect = userAnswers.size() == correctAnswers.length &&
Arrays.asList(correctAnswers).containsAll(userAnswers);
if (allCorrect) {
score += questionScore.getScore();
scoreDetails.append(questionScore.getScore()).append(" ");
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~true");
} else {
int halfScore = questionScore.getScore() / 2;
score += halfScore;
scoreDetails.append(halfScore).append(" ");
System.out.println(question.getContent() + "~" + String.join(" ", userAnswers) + "~partially correct");
}
}
} else { // 处理单项选择或填空题
if (userAnswer == null ||!userAnswer.trim().equals(question.getAnswerKey())) {
System.out.println(question.getContent() + "~" + (userAnswer!= null? userAnswer : "") + "~false");
scoreDetails.append("0 ");
} else {
score += questionScore.getScore();
scoreDetails.append(questionScore.getScore()).append(" ");
System.out.println(question.getContent() + "~" + userAnswer + "~true");
}
}
}
} else {
// 处理不存在的问题
System.out.println("non-existent question~0");
scoreDetails.append("0 ");
}
}
// 获取学生信息并输出成绩报告
Student student = studentMap.get(answerSheet.getStudentId());
if (student == null) {
System.out.println(answerSheet.getStudentId() + " not found");
} else {
System.out.printf("%s %s: %s~%d%n", student.getId(), student.getName(), scoreDetails.toString().trim(), score);
}
}
遍历排序后的每一张答题纸：
初始化学生得分score为 0，并创建StringBuilder对象scoreDetails用于记录每个问题的得分情况。
通过答题纸的试卷编号从TestPapersCollection中获取对应的试卷，如果试卷不存在则输出相应提示并跳过本次循环。
对于获取到的试卷，遍历其所有的QuestionScore对象，获取每个问题的分值设置：
根据问题编号从QuestionBank中获取对应的QuestionSet对象，如果问题不存在则进行相应处理（输出提示并给该问题记 0 分）。
如果问题存在且未被删除：
对于多项选择题，先将正确答案和用户答案都拆分成列表形式，然后通过stream的anyMatch等操作判断用户答案是否完全正确或部分正确，根据情况给分并记录得分细节。
对于单项选择或填空题，直接比较用户答案和正确答案是否一致，根据情况给分并记录得分细节。
最后根据答题纸的学生 ID 从Map<String, Student>中获取学生信息，如果学生信息不存在则输出相应提示，否则输出学生的成绩报告，包括学生 ID、姓名、每个问题的得分情况以及总分。
Main类
类名：Main
方法：main(String[] args)：程序的入口点，负责读取用户输入，根据输入格式进行相应的处理，如添加问题、试卷、学生信息、答题卡等，并最终调用Evaluation类的方法进行答题卡的处理和评分。
以上是我根据题目相关要求初步设计的类图和方法的一个大致思路，下面是一个我的详细类图：
调用顺序图如下：
SourceMonitor分析结果如下：
第五次大作业
7-1 家居强电电路模拟程序-1
分数 75
作者 蔡轲
单位 南昌航空大学
1、控制设备模拟
本题模拟的控制设备包括：开关、分档调速器、连续调速器。
开关：包括0和1两种状态。
开关有两个引脚，任意一个引脚都可以是输入引脚，而另一个则是输出引脚。开关状态为0时，无论输入电位是多少，输出引脚电位为0。当开关状态为1时，输出引脚电位等于输入电位。
分档调速器
按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器
没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚，一个固定的输入（引脚编号为1）、一个输出引脚（引脚编号为2）。当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。
所有控制设备的初始状态/档位为0。
2、受控设备模拟
本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。
灯有两种工作状态：亮、灭。在亮的状态下，有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态：停止、转动。风扇的转速会因引脚的电位差的不同而有区别。
本次迭代模拟两种灯具。
白炽灯：
亮度在0~200lux（流明）之间。
电位差为0-9V时亮度为0,其他电位差按比例，电位差10V对应50ux，220V对应200lux，其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯：
亮度为180lux。
只有两种状态，电位差为0时，亮度为0，电位差不为0，亮度为180。
本次迭代模拟一种吊扇。
工作电压区间为80V-150V，对应转速区间为80-360转/分钟。80V对应转速为80转/分钟，150V对应转速为360转/分钟，超过150V转速为360转/分钟（本次迭代暂不考虑电压超标的异常情况）。其他电压值与转速成正比，输入输出电位差小于80V时转速为0。
输入信息：
1、设备信息
分别用设备标识符K、F、L、B、R、D分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇。
设备标识用标识符+编号表示，如K1、F3、L2等。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。
三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件：
不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入，包含在连接信息中。
2、连接信息
一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。
格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2]表示K1的1引脚，K3的2引脚连接在一起。
约束条件：
本次迭代不考虑两个输出引脚短接的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如，
K1的输出接到L2的输入，L2的输出再接其他设备属于串联接线。
K1的输出接到L2的输出，同时K1的输入接到L2的输入，这种情况属于并联。
K1的输出接到L2的输入，K1的输入接到L2的输出，属于反馈接线。
3、控制设备调节信息
开关调节信息格式：
#+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。
分档调速器的调节信息格式：
#+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。
#+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。
连续调速器的调节信息格式：
#+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。
4、电源接地标识：VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。
输入信息以end为结束标志，忽略end之后的输入信息。
输出信息：
按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。
输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
本题不考虑输入电压或电压差超过220V的情况。
本题只考虑串联的形式，所以所有测试用例的所有连接信息都只包含两个引脚
本题电路中除了开关可能出现多个，其他电路设备均只出现一次。
电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。
家居电路模拟系列所有题目的默认规则：
1、当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。
2、所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。
3、连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。
4、对于调速器，其输入端只会直连VCC，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。
根据以上题目我分析得到：
这个题要求我用JAVA来实现一个家居强电电路模拟程序，能够模拟智能家居场景下的各种控制设备（如开关、分档调速器、连续调速器）和受控设备（如灯、风扇）的连接、控制以及状态输出。通过读取用户输入的设备连接信息、控制调节信息等，构建电路模型并展示各设备的当前状态或参数。
下面是我对于类的设计思路以及给出了部分类的代码实现：
Equipment抽象类
作为所有具体设备类的基类，定义了设备的一些通用属性（如title用于标识设备名称、voltage表示电压、current表示电流）以及必须由子类实现的抽象方法（getTitle用于获取设备标题、showDetails用于展示设备详细信息、turnOff用于关闭设备功能）。通过这种抽象设计，为不同类型的具体设备类提供了统一的接口规范，使得代码在处理各种设备时具有一致性和可扩展性。
abstract class Equipment {
String title;
double voltage;
double current;
public double getVoltage() {
return voltage;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getCurrent() {
return current;
}
public void setCurrent(double current) {
this.current = current;
}
abstract String getTitle();
abstract void showDetails();
abstract void turnOff();
}
CircuitSwitch类
继承关系：继承自Equipment抽象类，并实现了Comparable
作用：用于模拟电路中的开关设备。它包含一个私有属性mode来表示开关的状态（0 表示打开，1 表示闭合）。通过构造函数和setMode方法来初始化和更新开关状态，并根据状态计算电流值（打开时电流为 0，闭合时电流等于输入电压）。重写了getTitle、showDetails和turnOff等抽象方法，分别用于获取设备标题、按照规定格式（如@设备标识:turned on或@设备标识:closed）展示开关状态以及将开关设置为打开状态（即关闭设备功能）。实现Comparable接口使得可以对开关对象进行比较，比较依据是设备标题。
class CircuitSwitch extends Equipment implements Comparable<CircuitSwitch> {
private int mode;
public CircuitSwitch(double voltage, int mode, String title) {
this.title = title;
this.voltage = voltage;
this.mode = mode % 2;
this.current = (this.mode == 0) ? 0 : voltage;
}
public int getMode() {
return mode;
}
public void setMode(int mode) {
this.mode = mode % 2;
this.current = (this.mode == 0) ? 0 : voltage;
}
@Override
String getTitle() {
return title;
}
@Override
void showDetails() {
System.out.println("@" + title + ":" + (mode == 0 ? "turned on" : "closed")); // 移除中间的空格
}
@Override
void turnOff() {
// Functionality to turn off can be implemented here if needed
setMode(0);
}
@Override
public int compareTo(CircuitSwitch other) {
return this.title.compareTo(other.getTitle());
}
}
GearGovernor类
继承关系：继承自Equipment抽象类。
作用：用于模拟分档调速器设备。
它有一个私有属性gearSetting表示当前的档位设置。在构造函数中，根据传入的档位值通过setCurrentBasedOnGears方法计算并设置相应的电流值（不同档位对应不同比例的输入电压作为电流）。重写了getTitle、showDetails和turnOff等抽象方法，其中showDetails方法用于按照@设备标识:档位值的格式展示当前档位信息，turnOff方法可用于实现关闭设备的相关逻辑
class GearGovernor extends Equipment {
private int gearSetting;
GearGovernor(double voltage, int gearSetting, String title) {
this.gearSetting = gearSetting;
this.title = title;
this.voltage = voltage;
setCurrentBasedOnGears();
}
private void setCurrentBasedOnGears() {
if (gearSetting == 0) {
current = 0;
} else {
current = voltage * (0.3 + (gearSetting - 1) * 0.3);
}
}
@Override
String getTitle() {
return title;
}
@Override
void showDetails() {
System.out.println("@" + title + ":" + gearSetting); // 移除中间的空格
}
@Override
void turnOff() {
// Turn off logic if necessary
}
}
剩下只写出我设计了哪些类代码不作给出：
ContinuousGovernor类
-用于模拟连续调速器设备。它包含一个私有属性ratio表示档位比例。在构造函数中，根据传入的比例值计算电流值（电流等于输入电压乘以档位比例）。重写了getTitle、showDetails和turnOff等抽象方法，showDetails方法用于按照@设备标识:保留两位小数的档位比例值的格式展示当前档位信息，turnOff方法可用于添加关闭设备的相关功能。
IncandescentLight类
-用于模拟白炽灯设备。它有一个私有属性brightness用于存储灯泡的亮度值。在构造函数中，根据传入的电压值通过calculateBrightness方法计算灯泡的亮度（根据不同的电压范围采用不同的计算公式）。重写了getTitle、showDetails和turnOff等抽象方法，showDetails方法用于按照@设备标识:亮度值的格式展示灯泡的亮度，turnOff方法用于将灯泡亮度设置为 0，即关闭灯泡。
SolarLight类
-用于模拟日光灯设备。它包含一个私有属性brightness用于存储日光灯的亮度值。在构造函数中，根据传入的电压值简单判断并设置亮度值（电压不为 0 时亮度为 180，否则为 0）。重写了getTitle、showDetails和turnOff等抽象方法，showDetails方法用于按照@设备标识:亮度值的格式展示日光灯的亮度，turnOff方法用于将日光灯亮度设置为 0，即关闭日光灯。
FanDevice类
-用于模拟风扇设备。它有一个私有属性speed用于存储风扇的转速值。在构造函数中，根据传入的电压值通过calculateSpeed方法计算风扇的转速（根据不同的电压范围采用不同的计算公式）。重写了getTitle、showDetails和turnOff等抽象方法，showDetails方法用于按照@设备标识:转速值的格式展示风扇的转速，turnOff方法用于将风扇转速设置为 0，即关闭风扇。
EquipmentCollection类
-用于管理一系列的设备对象。它内部维护一个List
Main类
-创建了一些必要的数据结构，如Scanner用于读取用户输入，Map<String, Integer>用于跟踪开关状态变化次数，多个List用于存储连接信息、控制命令等。
通过循环读取用户输入，根据输入内容是否包含[或 ``#将其分别添加到对应的connections或commands列表中，直到读取到end` 为止。
对控制命令列表commands进行解析，针对不同类型的控制命令（开关、分档调速器、连续调速器）进行相应的处理，如更新开关状态跟踪信息、调整分档调速器的档位、设置连续调速器的档位比例等。
遍历连接信息列表connections，通过正则表达式匹配解析出连接的设备信息，根据设备类型创建相应的设备对象并添加到equipmentCollection中，在创建设备对象时，会根据前一个设备的输出电流作为当前设备的输入电压来构建电路连接关系。
最后调用equipmentCollection的displayAll方法，展示所有设备的状态或参数信息。
点击查看代码
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Map<String, Integer> switchTracker = new HashMap<>();
List<CircuitSwitch> switches = new ArrayList<>();
EquipmentCollection equipmentCollection = new EquipmentCollection();
List<String> connections = new ArrayList<>();
List<String> commands = new ArrayList<>();
while (true) {
String line = scanner.nextLine();
if (line.equals("end")) break;
if (line.contains("[")) connections.add(line);
else if (line.contains("#")) commands.add(line);
}
int governorSettings = 0;
double continuousRatio = 0;
if (!commands.isEmpty()) {
for (String command : commands) {
if (command.startsWith("#K")) {
Matcher matcher = Pattern.compile("#(K[0-9]+)").matcher(command);
while (matcher.find()) {
String switchName = matcher.group(1);
switchTracker.put(switchName, switchTracker.getOrDefault(switchName, 0) + 1);
}
} else if (command.startsWith("#F")) {
if (command.contains("+") && governorSettings < 3) governorSettings++;
if (command.contains("-") && governorSettings > 0) governorSettings--;
} else if (command.startsWith("#L")) {
Matcher matcher = Pattern.compile("#L[0-9]+:([0-9.]+)").matcher(command);
if (matcher.find()) {
continuousRatio = Double.parseDouble(matcher.group(1));
}
}
}
}
for (String connection : connections) {
Matcher matcher = Pattern.compile("\\[VCC ([A-Z0-9]+)\\-1\\]").matcher(connection);
if (matcher.find()) {
String name = matcher.group(1);
switchOrDevice(name, switchTracker, governorSettings, continuousRatio, equipmentCollection);
continue;
}
matcher = Pattern.compile("\\[[A-Z0-9]+\\-2 ([A-Z0-9]+)\\-1\\]").matcher(connection);
if (matcher.find()) {
String name = matcher.group(1);
String deviceType = name.substring(0, 1);
if (deviceType.equals("K")) {
CircuitSwitch newSwitch = createSwitch(name, equipmentCollection);
equipmentCollection.addDevice(newSwitch);
} else {
Equipment lastDevice = equipmentCollection.getDevices().get(equipmentCollection.getDevices().size() - 1);
switch (deviceType) {
case "D":
equipmentCollection.addDevice(new FanDevice(lastDevice.getCurrent(), name));
break;
case "B":
equipmentCollection.addDevice(new IncandescentLight(lastDevice.getCurrent(), name));
break;
case "R":
equipmentCollection.addDevice(new SolarLight(lastDevice.getCurrent(), name));
break;
}
}
}
if (connection.contains("GND")) break;
}
equipmentCollection.displayAll();
}
private static void switchOrDevice(String name, Map<String, Integer> switchTracker, int governorSettings, double continuousRatio, EquipmentCollection collection) {
if (name.contains("K")) {
int switchCount = switchTracker.getOrDefault(name, 0);
CircuitSwitch newSwitch = new CircuitSwitch(220, switchCount, name);
collection.addDevice(newSwitch);
} else if (name.contains("F")) {
collection.addDevice(new GearGovernor(220, governorSettings, name));
} else if (name.contains("L")) {
collection.addDevice(new ContinuousGovernor(220, continuousRatio, name));
} else if (name.contains("D")) {
collection.addDevice(new FanDevice(220, name));
} else if (name.contains("B")) {
collection.addDevice(new IncandescentLight(220, name));
} else if (name.contains("R")) {
collection.addDevice(new SolarLight(220, name));
}
}
private static CircuitSwitch createSwitch(String name, EquipmentCollection collection) {
return new CircuitSwitch(220, 0, name);
}
}
调用顺序图如下：
SourceMonitor分析结果如下：
第六次大作业：
7-1 家居强电电路模拟程序-2
相较于第五次大作业，本次多了电阻：
所有开关的电阻为 0，白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落地扇的电阻为 20
本次迭代模拟一种落地扇。
工作电压区间为 [80V,150V]，对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分 钟，[100-120)V 区间对应转速为 160 转/分钟，[120-140)V 区间对应转速为 260 转/分钟，超过 140V 转速 为 360 转/分钟（本次迭代暂不考虑电压超标的异常情况）输入信息：
电路中的短路如果不会在电路中产生无穷大的电流烧坏电路，都是合理情况，在本题测试点的考虑范围之内。
4、输出信息：
按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。
输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
家居电路模拟系列所有题目的默认规则：
1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。
2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。
3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。
4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。
电路结构变化：
迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
设计建议：
1、电路设备类：描述所有电路设备的公共特征。
2、受控设备类、控制设备类：对应受控、控制设备
3、串联电路类：一条由多个电路设备构成的串联电路，也看成是一个独立的电路设备
4、并联电路类：继承电路设备类，也看成是一个独立的电路设备
本次大作业我在上一次的大作业基础上重新构造了Equipment类。下面列出了它的属性和一些方法：
Equipment类
作用：作为一个抽象类，作为其他具体设备类的基类，定义了一些设备共有的属性和抽象方法，用于规范子类的行为。
属性：
switchstyle：用于表示开关样式相关的属性。
voltage：设备的电压值。
resistor：设备的电阻值。
name：设备的名称。
contact1、contact2：可能用于表示设备的连接点等相关属性。
方法：
getSwitchstyle()：获取开关样式属性值。
IfPathway()：用于判断设备是否构成通路，默认返回false，子类可根据具体情况重写。
getVoltage()：获取设备的电压值。
setVoltage(double c)：抽象方法，用于设置设备的电压值，子类必须实现。
getResistor()：抽象方法，用于获取设备的电阻值，子类必须实现。
getContact1()、setContact1(double contact1)：用于获取和设置contact1属性值。
getContact2()、setContact2(double contact2)：用于获取和设置contact2属性值。
getName()：获取设备的名称。
display()：抽象方法，用于展示设备的相关信息，子类必须实现。
close()：抽象方法，用于关闭设备或执行相关操作，子类必须实现。
新增的落地扇：
FloorFan类
作用：继承自Equipment类，表示落地扇设备，根据设置的电压值来确定落地扇的转速。
属性：
speed：表示落地扇的转速。
方法：
FloorFan(String name)：构造函数，用于创建落地扇对象并设置其电阻值和名称。
setVoltage(double c)：根据传入的电压值经过一系列计算来设置落地扇的转速。
getResistor()：重写父类方法，返回落地扇的电阻值。
display()：重写父类方法，展示落地扇的名称和转速值。
close()：重写父类方法，将落地扇转速设置为0，即关闭落地扇。
compareTo(FloorFan o)：实现Comparable接口的方法，用于按照名称对落地扇对象进行比较排序。
点击查看代码
class FloorFan extends Equipment implements Comparable<FloorFan> {
private int speed;
FloorFan(String name) {
super.name = name;
resistor = 20;
}
@Override
public void setVoltage(double c) {
double TF = c - Math.floor(c);
double TC = Math.ceil(c) - c;
if (Math.min(TF, TC) < 1e-10) {
c = Math.round(c);
}
if (c < 80) speed = 0;
else if (c >= 80 && c < 100) speed = 80;
else if (c >= 100 && c < 120) speed = 160;
else if (c >= 120 && c < 140) speed = 260;
else speed = 360;
}
@Override
double getResistor() {
return resistor;
}
@Override
void display() {
System.out.println("@" + name + ":" + speed);
}
@Override
void close() {
speed = 0;
}
@Override
public int compareTo(FloorFan o) {
return name.compareTo(o.getName());
}
}
添加了串联电路相关操作和属性的类：
Series类
作用：用于表示串联电路相关的操作和属性，管理一系列设备，可进行电压分配、通路检查、短路检查等操作。
属性：
voltage：串联电路的电压值。
name：串联电路的名称。
resistor：串联电路的总电阻值。
list：存储串联电路中的设备列表。
方法：
getVoltage()、setVoltage(double voltage)：用于获取和设置串联电路的电压值。
getName()、setName(String name)：用于获取和设置串联电路的名称。
VoltageDivision()：根据串联电路的总电阻和各设备电阻进行电压分配操作。
getResistor()：计算并返回串联电路的总电阻值。
IfPathway()：检查串联电路是否构成通路。
Ifshort()：检查串联电路是否短路。
getList()、setList(List<Equipment> list)：用于获取和设置串联电路中的设备列表。
addEquipment(Equipment e)：向串联电路中添加设备。
getEquipment(int index)：获取串联电路中指定索引的设备。
点击查看代码
class Series {
public double getVoltage() {
return voltage;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
private double voltage;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private String name;
public void VoltageDivision() {
double aver = getVoltage() / getResistor();
for (Equipment e : list) {
if (e instanceof Switch || e instanceof Governor || e instanceof ContinueGovernor) {
continue;
} else {
e.setVoltage(aver * e.getResistor());
}
}
}
private double resistor;
public double getResistor() {
resistor = 0;
for (Equipment e : list) {
if (e instanceof Switch || e instanceof Governor || e instanceof ContinueGovernor)
continue;
else
resistor += e.getResistor();
}
return resistor;
}
public boolean IfPathway() {
for (Equipment e : list) {
if (e instanceof Switch) {
if (e.switchstyle == 0) {
return false;
}
} else if (e instanceof Parallel && !e.IfPathway()) {
return false;
}
}
return true;
}
public boolean Ifshort() { // 检查是否短路
for (Equipment e : list) {
if (e instanceof Switch && e.switchstyle == 1) {
return false;
}
}
return true;
}
public List<Equipment> getList() {
return list;
}
public void setList(List<Equipment> list) {
this.list = list;
}
private List<Equipment> list;
Series() {
list = new ArrayList<>();
}
public void addEquipment(Equipment e) {
list.add(e);
}
public Equipment getEquipment(int index) {
return list.get(index - 1);
}
}
Parallel类
作用：继承自Equipment类，用于表示并联电路相关的操作和属性，管理多个串联电路组成的并联电路，可进行电压设置、通路检查等操作。
属性：
seriesList：存储组成并联电路的各个串联电路列表。
方法：
Parallel(List<Series> seriesList)：构造函数，用于创建并联电路对象并传入组成它的串联电路列表。
setVoltage(double c)：根据并联电路是否通路来设置各串联电路的电压并进行电压分配操作。
IfPathway()：检查并联电路是否构成通路。
getResistor()：计算并返回并联电路的等效电阻值。
display()、close()：重写父类方法，这里为空实现。
点击查看代码
class Parallel extends Equipment {
private List<Series> seriesList;
Parallel(List<Series> seriesList) {
this.seriesList = seriesList;
}
@Override
public void setVoltage(double c) {
for (Series series : seriesList) {
if (series.IfPathway()) {
series.setVoltage(c);
series.VoltageDivision();
}
}
}
@Override
public boolean IfPathway() { // 检查并联是否通路
for (Series series : seriesList) {
if (series.IfPathway()) {
return true;
}
}
return false;
}
@Override
double getResistor() {
for (Series series : seriesList) {
if (series.Ifshort()) {
return 0;
}
}
double r = 0;
double R = 0;
for (Series series : seriesList) {
if (series.IfPathway()) {
R += (1.0 / series.getResistor());
}
}
return (1.0 / R);
}
@Override
void display() { }
@Override
void close() { }
}
Main类
作用：包含main方法，作为程序的入口点，用于读取用户输入的信息，创建各种设备对象并将它们添加到相应的电路（串联或并联）中，然后根据用户输入设置相关设备参数，最后检查电路是否通路并进行相应操作（如分压、展示设备信息等）。
以上是我根据题目相关要求初步设计的类图和方法的一个大致思路，下面是一个我的详细类图：
调用顺序图如下：
SourceMonitor分析结果如下：
学习总结
通过本阶段的三次题目集练习，我在面向对象编程领域取得了显著的进步，对其核心概念与设计理念有了更为深入且全面的理解。
在面向对象编程的实践中，抽象类与接口的运用成为了我构建灵活且可扩展代码架构的有力工具。抽象类作为一种特殊的基类，允许我定义一些共性的方法与属性，这些抽象方法在子类中得以具体实现，从而确保了代码的一致性与规范性。通过这种方式，我能够在多个子类中复用抽象类中定义的通用逻辑，避免了代码的重复编写，极大地提升了代码的可重用性。例如，在处理一系列具有相似行为但又存在细微差异的对象时，抽象类能够精准地捕捉到它们的共性，将其抽象出来并提供一个统一的框架，使得子类可以在这个框架基础上进行个性化的扩展。这种代码复用机制不仅减少了代码量，降低了维护成本，还使得整个代码体系更加清晰易懂，便于后续的开发与维护。
同时，我深刻认识到重复代码是编程过程中的一大隐患。重复代码不仅增加了代码的长度，使得代码库显得臃肿不堪，更重要的是，它显著提升了维护的难度与成本。每当需要对重复代码中的逻辑进行修改时，都必须在多个位置进行相同的操作，这极易导致疏漏与错误。因此，我学会了仔细审视代码，积极寻找并提取其中的通用逻辑，将其封装成独立的方法或类，以便在不同的场景中进行复用。在涉及到重复计算的部分，我也会进行优化处理，避免不必要的计算开销，从而提高代码的执行效率。例如，对于一些在多个地方都需要进行的复杂数学运算或数据处理操作，我会将其封装成一个专门的工具类方法，这样在需要使用该计算逻辑的地方，只需简单调用该方法即可，既保证了计算的准确性与一致性，又提高了代码的运行速度。
正则表达式的学习与应用也是本次练习的一大收获。正则表达式作为一种强大的文本处理工具，能够以简洁而高效的方式匹配和解析各种复杂的输入字符串。在处理用户输入、文件读取或数据验证等场景时，正则表达式发挥了不可替代的作用。它使得我的代码能够更加灵活地应对各种不同格式的输入数据，轻松地提取出所需的信息，并进行相应的处理。例如，在处理用户输入的表单数据时，通过使用正则表达式，可以快速验证输入的格式是否符合要求，如答题信息等的格式验证，大大提高了程序的交互性与数据处理的准确性。
在代码编写过程中，我逐渐意识到设计模式的重要性及其广泛的应用场景。设计模式犹如编程世界中的蓝图，为解决各类常见问题提供了经过实践验证的优秀解决方案。例如模板方法模式，它通过定义一个算法的骨架，将一些步骤的具体实现延迟到子类中，使得子类可以在不改变算法整体结构的前提下，灵活地定制某些步骤的具体行为。这种模式在处理具有固定流程但部分环节存在差异的业务逻辑时非常有效，能够显著提高代码的复用性与扩展性。又如策略模式，它允许在运行时根据不同的条件选择不同的算法或行为策略，使得代码能够更加动态地适应各种变化的需求。通过合理地运用这些设计模式，我能够将复杂的业务逻辑分解为多个简单且独立的组件，每个组件专注于完成特定的任务，从而降低了代码之间的耦合度。低耦合的代码结构使得各个组件之间的依赖关系更加清晰，易于理解与维护，当需求发生变化时，只需对相关的组件进行修改或替换，而不会对整个系统造成大规模的影响，大大提高了代码的灵活性与可维护性。
然而，在实践过程中我也充分认识到自己的不足之处。异常处理是编程中至关重要的一环，但我在之前的代码编写中往往容易忽视。在实际运行环境中，各种异常情况都有可能发生，如文件读取失败、网络连接中断、数据类型不匹配等。如果没有完善的异常处理机制，程序很可能会在遇到异常时突然崩溃，给用户带来极差的体验，甚至可能导致数据丢失或系统故障。因此，我学会了在编写代码时，仔细分析每一个可能出现异常的环节，并针对性地添加适当的异常处理代码。例如，在进行文件读取操作时，使用try-catch块来捕获可能出现的IOException异常，并在catch块中进行相应的处理，如提示用户文件读取失败的原因，或者提供一些备选的处理方案，确保程序在面对异常情况时能够保持稳定运行，或者至少能够给出合理的反馈信息，告知用户当前的异常状态，从而增强了代码的健壮性与可靠性。
此外，编写测试用例与熟练运用调试工具也是我在本次练习中重点提升的技能。测试用例就像是代码的质检员，能够帮助我在代码开发过程中及时发现潜在的问题与漏洞。通过编写全面且细致的测试用例，我可以对代码的各种功能模块进行系统性的测试，覆盖不同的输入情况与边界条件，确保代码在各种预期与非预期的场景下都能正确运行。在调试过程中，调试工具成为了我不可或缺的得力助手。通过设置断点、逐步执行代码、查看变量值等调试手段，我能够深入到代码的执行流程中，精准地定位问题所在，并及时进行修复。这不仅提高了我解决问题的效率，还使得我能够更加深入地理解代码的运行机制，从而进一步优化代码的质量。
编写代码本质上是一个解决问题的过程，而三次题目集的练习让我学会了如何将一个庞大而复杂的问题逐步分解为更小的、更易于管理与解决的子问题。这种分而治之的策略使得整个编程任务不再那么令人生畏，我可以有条不紊地对每个子问题进行分析、设计与实现，最终将各个子问题的解决方案整合起来，完成整个任务。在这个过程中，我深刻体会到编写代码并非一帆风顺，尤其是在调试和解决bug的阶段，往往需要花费大量的时间与精力。有时，一个看似微不足道的bug可能会隐藏在代码的深处，需要反复排查与调试才能发现。但正是通过这些不断尝试与改进的过程，我逐渐培养了自己的耐心与毅力，学会了在面对困难与挫折时保持冷静，坚持不懈地寻找解决方案，这种心态的转变对于我在编程领域的长期发展具有极为重要的意义。
综上所述，通过这三次题目集的练习，我在面向对象编程的知识与技能方面实现了全面的提升。我不仅熟练掌握了抽象类、接口、设计模式等核心概念与技术的应用，还在代码质量、可维护性、健壮性以及问题解决能力等方面取得了长足的进步，这将为我今后在实际开发工作中应对各种复杂的挑战与多样化的需求奠定坚实的基础。
浙公网安备 33010602011771号