前言
第4到6次大作业分为两个部分，第4次大作业是对上三次大作业的最终迭代，第5到第6次是新的大作业，是关于电路的迭代。
设计与分析
第四次大作业题目：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。本题在答题判题程序-3基础上新增的内容统一附加在输出格式说明之后，用粗体标明。
输入格式: 程序输入信息分五种，信息可能会打乱顺序混合输入。1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2#N:2 #Q:2+2= #A:42、试卷信息试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。 \格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：题目编号应与题目信息中的编号对应。一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2 3、学生信息学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：#S:1 #A:5 #A:221是试卷号 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-41是试卷号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 points2、答卷信息一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。格式：题目内容+"~"+答案++"~"+判题结果（true/false）约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。样例：answer is null3+2=~5~true4+6=~22~false.answer is null3、判分信息判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：1、没有输入答案的题目、被删除的题目、答案错误的题目计0分2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。4、被删除的题目提示信息当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。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~06、格式错误提示信息输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。例如：wrong format:2 #Q:2+2= #47、试卷号引用错误提示输出如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。8、学号引用错误提示信息如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。本次作业新增内容：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~42、输入填空题题目信息题目信息为独行输入，一行为一道题，多道题可分多行输入。格式："#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~53、输出顺序变化只要是正确格式的信息，可以以任意的先后顺序输入各类不同的信息。比如试卷可以出现在题目之前，删除题目的信息可以出现在题目之前等。例如：
#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~04、多张试卷信息本题考虑多个同学有多张不同试卷的答卷的情况。输出顺序优先级为学号、试卷号，按从小到大的顺序先按学号排序，再按试卷号。例如：
#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
20201104 Jack: 0 10~10
分析思路
为了实现这个复杂的答题程序，需要设计多个类来处理题目、试卷、学生、答卷和删除信息，并确保能够根据标准答案正确地判定得分和输出结果。
- 定义题目类 Question
点击查看代码
import java.io.Serializable;public class Question implements Serializable {private int id;private String content;private String answer;public Question(int id, String content, String answer) {this.id = id;this.content = content;this.answer = answer;}public int getId() {return id;}public String getContent() {return content;}public String getAnswer() {return answer;}
}- 定义选择题类 ChoiceQuestion
点击查看代码
public class ChoiceQuestion extends Question {public ChoiceQuestion(int id, String content, String answer) {super(id, content, answer);}public boolean isCorrect(String answer) {String[] correctAnswers = getAnswer().split(" ");String[] studentAnswers = answer.split(" ");int correctCount = 0;for (String studentAnswer : studentAnswers) {if (!studentAnswer.isEmpty()) {boolean found = false;for (String correctAnswer : correctAnswers) {if (correctAnswer.equals(studentAnswer)) {found = true;correctCount++;break;}}if (!found) {return false;}}}if (correctCount == correctAnswers.length) {return true;} else if (correctCount > 0) {return false; // Partially correct case is handled in the scoring logic} else {return false;}}
}- 定义填空题类 FillInTheBlankQuestion
点击查看代码
public class FillInTheBlankQuestion extends Question {public FillInTheBlankQuestion(int id, String content, String answer) {super(id, content, answer);}public boolean isCorrect(String answer) {return getAnswer().equals(answer);}
}- 定义试卷类 TestPaper
点击查看代码
import java.util.HashMap;
import java.util.Map;public class TestPaper {private int id;private Map<Integer, Integer> questions; // questionId -> pointspublic TestPaper(int id) {this.id = id;this.questions = new HashMap<>();}public int getId() {return id;}public void addQuestion(int questionId, int points) {questions.put(questionId, points);}public Map<Integer, Integer> getQuestions() {return questions;}public int getTotalPoints() {int total = 0;for (int points : questions.values()) {total += points;}return total;}
}- 定义学生类 Student
点击查看代码
public class Student {private String id;private String name;public Student(String id, String name) {this.id = id;this.name = name;}public String getId() {return id;}public String getName() {return name;}
}- 定义答卷类 AnswerSheet
点击查看代码
import java.util.HashMap;
import java.util.Map;public class AnswerSheet {private int testPaperId;private String studentId;private Map<Integer, String> answers; // questionOrder -> answerpublic AnswerSheet(int testPaperId, String studentId) {this.testPaperId = testPaperId;this.studentId = studentId;this.answers = new HashMap<>();}public int getTestPaperId() {return testPaperId;}public String getStudentId() {return studentId;}public void addAnswer(int questionOrder, String answer) {answers.put(questionOrder, answer);}public Map<Integer, String> getAnswers() {return answers;}
}- 定义主类 ExamSystem
点击查看代码
import java.util.*;public class ExamSystem {private Map<Integer, Question> questions = new HashMap<>();private Map<Integer, TestPaper> testPapers = new HashMap<>();private Map<String, Student> students = new HashMap<>();private List<AnswerSheet> answerSheets = new ArrayList<>();private Set<Integer> deletedQuestions = new HashSet<>();public void addQuestion(Question question) {questions.put(question.getId(), question);}public void addTestPaper(TestPaper testPaper) {testPapers.put(testPaper.getId(), testPaper);}public void addStudent(Student student) {students.put(student.getId(), student);}public void addAnswerSheet(AnswerSheet answerSheet) {answerSheets.add(answerSheet);}public void deleteQuestion(int questionId) {deletedQuestions.add(questionId);}public void checkTestPapers() {for (TestPaper testPaper : testPapers.values()) {if (testPaper.getTotalPoints() != 100) {System.out.println("alert: full score of test paper " + testPaper.getId() + " is not 100 points");}}}public void gradeAnswerSheets() {for (AnswerSheet answerSheet : answerSheets) {TestPaper testPaper = testPapers.get(answerSheet.getTestPaperId());if (testPaper == null) {System.out.println("the test paper number does not exist");continue;}Student student = students.get(answerSheet.getStudentId());if (student == null) {System.out.println("the student number does not exist");continue;}int totalScore = 0;StringBuilder result = new StringBuilder();for (Map.Entry<Integer, Integer> entry : testPaper.getQuestions().entrySet()) {int questionId = entry.getKey();int points = entry.getValue();String studentAnswer = answerSheet.getAnswers().get(questionId);Question question = questions.get(questionId);if (deletedQuestions.contains(questionId)) {result.append("the question ").append(questionId).append(" invalid~0\n");continue;}if (question == null) {result.append("non-existent question~0\n");continue;}if (studentAnswer == null || studentAnswer.trim().isEmpty()) {result.append("answer is null\n");continue;}boolean correct = false;if (question instanceof ChoiceQuestion) {ChoiceQuestion choiceQuestion = (ChoiceQuestion) question;correct = choiceQuestion.isCorrect(studentAnswer.trim());} else if (question instanceof FillInTheBlankQuestion) {FillInTheBlankQuestion fillInTheBlankQuestion = (FillInTheBlankQuestion) question;correct = fillInTheBlankQuestion.isCorrect(studentAnswer.trim());} else {correct = question.getAnswer().equals(studentAnswer.trim());}result.append(question.getContent()).append("~").append(studentAnswer).append("~").append(correct).append("\n");if (correct) {totalScore += points;}}System.out.println(result.toString().trim());System.out.println(student.getId() + " " + student.getName() + ": " + totalScore);}}public static void main(String[] args) {ExamSystem system = new ExamSystem();// 示例数据system.addQuestion(new Question(1, "1+1=", "2"));system.addQuestion(new ChoiceQuestion(2, "党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信", "A B C D"));system.addQuestion(new FillInTheBlankQuestion(3, "古琴在古代被称为：", "瑶琴或七弦琴"));TestPaper testPaper1 = new TestPaper(1);testPaper1.addQuestion(1, 5);testPaper1.addQuestion(2, 10);system.addTestPaper(testPaper1);system.addStudent(new Student("20201103", "Tom"));AnswerSheet answerSheet1 = new AnswerSheet(1, "20201103");answerSheet1.addAnswer(1, "5");answerSheet1.addAnswer(2, "A B C");system.addAnswerSheet(answerSheet1);system.checkTestPapers();system.gradeAnswerSheets();}
}- 问题类：Question 是基本类，ChoiceQuestion 是选择题类，FillInTheBlankQuestion 是填空题类。
- 试卷类：TestPaper 包含题目编号和题目分值。
- 学生类：Student 包含学生ID和姓名。
- 答卷类：AnswerSheet 包含试卷号和学生的答案。
- 主类：ExamSystem 负责添加数据、检查试卷分数、判卷并输出结果。
这是这段代码的耦合度图。图中的节点代表各个类，边表示类之间的关系。ExamSystem 类与大多数其他类都有关系，因为它负责管理系统中的主要逻辑和数据。其余的类根据它们的功能和相互依赖关系建立了联系。
图中的关系：
ChoiceQuestion 和 FillInTheBlankQuestion 继承了 Question 类。
TestPaper 与 Question 类相关，因为试卷中包含题目。
AnswerSheet 与 TestPaper 和 Student 类相关，因为答卷与试卷和学生信息相关。
ExamSystem 类管理所有其他类，并与它们建立了关系。
类图
点击查看代码
+-------------------+
| Question |
+-------------------+
| - id: String |
| - content: String |
| - answer: String |
| - type: String |
+-------------------+
| + Question(id: |
| String, content:|
| String, answer: |
| String, type: |
| String) |
+-------------------++----------------------+
| Paper |
+----------------------+
| - id: String |
| - questions: Map |
| <String, Integer> |
+----------------------+
| + Paper(id: String) |
| + addQuestion( |
| questionId: String,|
| score: int) |
| + totalScore(): int |
+----------------------++-------------------+
| Student |
+-------------------+
| - id: String |
| - name: String |
+-------------------+
| + Student(id: |
| String, name: |
| String) |
+-------------------++----------------------+
| Answer |
+----------------------+
| - paperId: String |
| - studentId: String |
| - answers: Map |
| <Integer, String> |
+----------------------+
| + Answer(paperId: |
| String, studentId: |
| String) |
| + addAnswer( |
| questionIndex: int,|
| answer: String) |
+----------------------++-----------------------------+
| TestSystem |
+-----------------------------+
| + questions: Map<String, |
| Question> |
| + papers: Map<String, Paper>|
| + students: Map<String, |
| Student> |
| + answers: List<Answer> |
| + deletedQuestions: Set< |
| String> |
+-----------------------------+
| + main(args: String[]) |
| + addQuestion(input: String)|
| + addPaper(input: String) |
| + addStudents(input: String)|
| + addAnswer(input: String) |
| + deleteQuestion(input: |
| String) |
| + processAnswers() |
+-----------------------------+这段代码仍存在一些容易踩坑的地方。
1、输入格式验证不充分：代码假设所有输入格式都是正确的，如果输入格式不正确，例如缺少必需的字段或者格式不匹配，可能会导致程序崩溃或者行为异常。需要增加输入格式的验证和错误处理。2、答案顺序的处理：代码假设答卷中的题目顺序号和题目编号一致，然而这两者可能不一致。需要确保答卷中的顺序号正确映射到题目编号。3、多选题和填空题的判分逻辑：多选题和填空题的判分逻辑目前只考虑完全正确或完全错误的情况。部分正确的情况判定逻辑可以更细化，并且应该确保没有遗漏或错误。4、试卷分数计算问题：代码只检查试卷的总分是否为100分，但没有处理试卷中的每一道题目的分值。如果题目的分值总和不合理，可能会导致错误的警告信息。5、并发问题：在多线程环境下，如果多个线程同时修改同一个集合（如题目列表、试卷列表等），可能会引发并发问题。需要考虑线程安全的问题。6、删除题目的处理：代码只处理删除题目的基本情况，如果删除的题目在答卷中存在，可能会导致不一致的状态。需要确保删除题目后，所有相关的数据结构和状态都能正确更新。7、输出格式问题：输出格式假设所有输入都是正确的，如果某个输入字段缺失或者格式不对，输出可能会不符合预期。需要增加对输出格式的检查和错误处理。8、代码的扩展性和可维护性：目前的代码没有很好地遵循单一职责原则，特别是 ExamSystem 类承担了过多的职责。可以考虑将不同的职责分离到不同的类中，以提高代码的可维护性和扩展性。
解决建议：
增加输入格式的验证：
增加对输入格式的严格验证，确保输入的格式正确，并对不符合格式的输入给出明确的错误提示。改进判分逻辑：
增加对多选题和填空题部分正确的处理逻辑，确保能够正确判定部分正确的答案并给出合理的分数。处理并发问题：
如果考虑在多线程环境下运行，使用线程安全的数据结构或者增加适当的同步机制，确保线程安全。改进删除题目的处理：
确保删除题目后，所有相关的数据结构和状态都能正确更新，避免不一致的状态。改进代码的结构和职责划分：
重新设计类的职责划分，确保每个类只承担单一职责，提高代码的可维护性和扩展性。
通过以上改进，可以使代码更加健壮，易于维护和扩展，并减少潜在的踩坑问题。
第5次大作业题目：
智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。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。控制设备的输入引脚编号为1，输出引脚编号为2。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 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。约束条件：本次迭代不考虑两个输出引脚短接的情况
考虑调速器输出串联到其他控制设备（开关）的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如，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，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。家居电路模拟系列1-4题目后续迭代设计：1、电路结构变化：迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系电路结构变化示意图见图1。2、输入信息的变化串联线路信息：用于记录一段串联电路的元件与连接信息。例如： #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]并联线路信息：用于记录一段并联电路所包含的所有串联电路信息。例如：#M1:[T1 T2 T3]以上格式仅做参考，格式细节可能会调整，以具体发布的为准。3、计算方式的变化迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。4、电路元件的变化每次迭代会增加1-2个新的电路元件。
智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。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。控制设备的输入引脚编号为1，输出引脚编号为2。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 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。约束条件：本次迭代不考虑两个输出引脚短接的情况
考虑调速器输出串联到其他控制设备（开关）的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如，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，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。家居电路模拟系列1-4题目后续迭代设计：1、电路结构变化：迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系电路结构变化示意图见图1。2、输入信息的变化串联线路信息：用于记录一段串联电路的元件与连接信息。例如： #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]并联线路信息：用于记录一段并联电路所包含的所有串联电路信息。例如：#M1:[T1 T2 T3]以上格式仅做参考，格式细节可能会调整，以具体发布的为准。3、计算方式的变化迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。4、电路元件的变化每次迭代会增加1-2个新的电路元件。
设计建议：1、电路设备类：描述所有电路设备的公共特征。2、受控设备类、控制设备类：对应受控、控制设备3、串联电路类：一条由多个电路设备构成的串联电路，也看成是一个独立的电路设备其他类以及类的属性、方法自行设计。电路图
设计类图
分析思路
1、Main.java： 主要程序入口。负责初始化电路、读取输入信息、应用调节信息、计算输出并打印结果。
点击查看代码
import java.util.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);Circuit circuit = new Circuit();circuit.addControlDevice("K1", new Switch());circuit.addControlDevice("F1", new SteppedSpeedController());circuit.addControlDevice("L1", new ContinuousSpeedController());circuit.addControlledDevice("D2", new IncandescentLamp());circuit.addControlledDevice("B2", new FluorescentLamp());circuit.addControlledDevice("R2", new CeilingFan());List<String> adjustments = new ArrayList<>();while (scanner.hasNextLine()) {String line = scanner.nextLine();if (line.equals("end")) {break;}if (line.startsWith("[")) {String[] parts = line.substring(1, line.length() - 1).split(" ");circuit.addConnection(new Connection(parts[0], parts[1]));} else if (line.startsWith("#")) {adjustments.add(line);}}for (ControlDevice device : circuit.getControlDevices().values()) {device.setInputVoltage(220);}circuit.applyAdjustments(adjustments);circuit.calculateOutputs();circuit.printResults();}
}2、Circuit.java： 表示电路系统，管理控制设备、被控设备和它们之间的连接。负责应用调节信息，计算输出并打印结果。
点击查看代码
import java.util.*;public class Circuit {private Map<String, ControlDevice> controlDevices = new HashMap<>();private Map<String, ControlledDevice> controlledDevices = new HashMap<>();private List<Connection> connections = new ArrayList<>();private Set<String> affectedDevices = new HashSet<>();public void addControlDevice(String id, ControlDevice device) {controlDevices.put(id, device);}public void addControlledDevice(String id, ControlledDevice device) {controlledDevices.put(id, device);}public void addConnection(Connection connection) {connections.add(connection);}public void applyAdjustments(List<String> adjustments) {for (String adjustment : adjustments) {String id = adjustment.substring(1, 3);ControlDevice device = controlDevices.get(id);if (device == null) continue;affectedDevices.add(id);if (device instanceof Switch) {((Switch) device).toggle();} else if (device instanceof SteppedSpeedController) {if (adjustment.charAt(3) == '+') {((SteppedSpeedController) device).increaseLevel();} else if (adjustment.charAt(3) == '-') {((SteppedSpeedController) device).decreaseLevel();}} else if (device instanceof ContinuousSpeedController) {double level = Double.parseDouble(adjustment.substring(4));((ContinuousSpeedController) device).setLevel(level);}}}public void calculateOutputs() {for (Connection connection : connections) {String fromId = connection.getFrom().split("-")[0];String toId = connection.getTo().split("-")[0];ControlDevice fromDevice = controlDevices.get(fromId);ControlledDevice toDevice = controlledDevices.get(toId);if (fromDevice != null && toDevice != null) {toDevice.setVoltage(fromDevice.getOutputVoltage());affectedDevices.add(toId);}}}public void printResults() {List<String> deviceOrder = new ArrayList<>();for (Connection connection : connections) {String fromId = connection.getFrom().split("-")[0];String toId = connection.getTo().split("-")[0];if (!deviceOrder.contains(fromId)) {deviceOrder.add(fromId);}if (!deviceOrder.contains(toId)) {deviceOrder.add(toId);}}for (String id : deviceOrder) {if (controlDevices.containsKey(id)) {System.out.println(controlDevices.get(id));} else if (controlledDevices.containsKey(id)) {System.out.println(controlledDevices.get(id));}}}public Map<String, ControlDevice> getControlDevices() {return controlDevices;}public Map<String, ControlledDevice> getControlledDevices() {return controlledDevices;}
}3、Connection.java： 表示两个设备之间的连接。包含起始设备和目标设备的标识符。
点击查看代码
public class Connection {private String from;private String to;public Connection(String from, String to) {this.from = from;this.to = to;}public String getFrom() {return from;}public String getTo() {return to;}
}4、ControlDevice.java： 抽象类，表示控制设备。包含设置输入电压、获取输出电压的方法和计算输出电压的抽象方法。
点击查看代码
abstract class ControlDevice {protected int inputVoltage;protected int outputVoltage;public void setInputVoltage(int voltage) {this.inputVoltage = voltage;calculateOutputVoltage();}public int getOutputVoltage() {return outputVoltage;}protected abstract void calculateOutputVoltage();public abstract String getId();@Overridepublic abstract String toString();
}5、Switch.java： 继承自 ControlDevice，表示开关设备。包含开关的状态（开/关）及其电压输出逻辑。
点击查看代码
public class Switch extends ControlDevice {private boolean isClosed = false;public void toggle() {isClosed = !isClosed;calculateOutputVoltage();}@Overrideprotected void calculateOutputVoltage() {outputVoltage = isClosed ? inputVoltage : 0;}@Overridepublic String getId() {return "K1";}@Overridepublic String toString() {return "@K1:" + (isClosed ? "closed" : "turned on");}
}6、SteppedSpeedController.java： 继承自 ControlDevice，表示分级调速器。包含调节调速级别的方法和相应的电压输出逻辑。
点击查看代码
public class SteppedSpeedController extends ControlDevice {private int level = 0;public void increaseLevel() {if (level < 3) {level++;calculateOutputVoltage();}}public void decreaseLevel() {if (level > 0) {level--;calculateOutputVoltage();}}@Overrideprotected void calculateOutputVoltage() {outputVoltage = inputVoltage * (level + 1) / 3;}@Overridepublic String getId() {return "F1";}@Overridepublic String toString() {return "@F1:" + level;}
}7、ContinuousSpeedController.java： 继承自 ControlDevice，表示连续调速器。包含设置调速级别的方法和相应的电压输出逻辑。
点击查看代码
public class ContinuousSpeedController extends ControlDevice {private double level = 0.0;public void setLevel(double level) {this.level = level;calculateOutputVoltage();}@Overrideprotected void calculateOutputVoltage() {outputVoltage = (int) (inputVoltage * level);}@Overridepublic String getId() {return "L1";}@Overridepublic String toString() {return String.format("@L1:%.2f", level);}
}8、ControlledDevice.java： 抽象类，表示被控设备。包含设置电压的方法，具体设备需要实现该方法。
点击查看代码
abstract class ControlledDevice {protected int brightnessOrSpeed;public abstract void setVoltage(int voltage);@Overridepublic abstract String toString();
}9、IncandescentLamp.java： 继承自 ControlledDevice，表示白炽灯。根据输入电压设置亮度。
点击查看代码
public class IncandescentLamp extends ControlledDevice {@Overridepublic void setVoltage(int voltage) {if (voltage < 80) {brightnessOrSpeed = 0;} else if (voltage > 150) {brightnessOrSpeed = 360;} else {brightnessOrSpeed = (int) (80 + (280.0 / 70.0) * (voltage - 80));}}@Overridepublic String toString() {return "@D2:" + brightnessOrSpeed;}
}10、FluorescentLamp.java： 继承自 ControlledDevice，表示荧光灯。根据输入电压设置亮度。电压在0到9之间时亮度为0，电压在10到220之间时，亮度按比例设置，最大亮度为200。
点击查看代码
public class FluorescentLamp extends ControlledDevice {@Overridepublic void setVoltage(int voltage) {if (voltage >= 0 && voltage <= 9) {brightnessOrSpeed = 0;} else {brightnessOrSpeed = (int) ((voltage - 10.0) / 210.0 * 200);brightnessOrSpeed = Math.min(200, Math.max(0, brightnessOrSpeed)); // 限制在0-200之间}}@Overridepublic String toString() {return "@B2:" + brightnessOrSpeed;}
}完整代码
点击查看代码
import java.util.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);Circuit circuit = new Circuit();circuit.addControlDevice("K1", new Switch());circuit.addControlDevice("F1", new SteppedSpeedController());circuit.addControlDevice("L1", new ContinuousSpeedController());circuit.addControlledDevice("D2", new IncandescentLamp());circuit.addControlledDevice("B2", new FluorescentLamp());circuit.addControlledDevice("R2", new CeilingFan());List<String> adjustments = new ArrayList<>();while (scanner.hasNextLine()) {String line = scanner.nextLine();if (line.equals("end")) {break;}if (line.startsWith("[")) {String[] parts = line.substring(1, line.length() - 1).split(" ");circuit.addConnection(new Connection(parts[0], parts[1]));} else if (line.startsWith("#")) {adjustments.add(line);}}for (ControlDevice device : circuit.getControlDevices().values()) {device.setInputVoltage(220);}circuit.applyAdjustments(adjustments);circuit.calculateOutputs();circuit.printResults();}
}class Circuit {private Map<String, ControlDevice> controlDevices = new HashMap<>();private Map<String, ControlledDevice> controlledDevices = new HashMap<>();private List<Connection> connections = new ArrayList<>();private Set<String> affectedDevices = new HashSet<>();public void addControlDevice(String id, ControlDevice device) {controlDevices.put(id, device);}public void addControlledDevice(String id, ControlledDevice device) {controlledDevices.put(id, device);}public void addConnection(Connection connection) {connections.add(connection);}public void applyAdjustments(List<String> adjustments) {for (String adjustment : adjustments) {String id = adjustment.substring(1, 3);ControlDevice device = controlDevices.get(id);if (device == null) continue;affectedDevices.add(id);if (device instanceof Switch) {((Switch) device).toggle();} else if (device instanceof SteppedSpeedController) {if (adjustment.charAt(3) == '+') {((SteppedSpeedController) device).increaseLevel();} else if (adjustment.charAt(3) == '-') {((SteppedSpeedController) device).decreaseLevel();}} else if (device instanceof ContinuousSpeedController) {double level = Double.parseDouble(adjustment.substring(4));((ContinuousSpeedController) device).setLevel(level);}}}public void calculateOutputs() {for (Connection connection : connections) {String fromId = connection.getFrom().split("-")[0];String toId = connection.getTo().split("-")[0];ControlDevice fromDevice = controlDevices.get(fromId);ControlledDevice toDevice = controlledDevices.get(toId);if (fromDevice != null && toDevice != null) {toDevice.setVoltage(fromDevice.getOutputVoltage());affectedDevices.add(toId);}}}public void printResults() {List<String> deviceOrder = new ArrayList<>();for (Connection connection : connections) {String fromId = connection.getFrom().split("-")[0];String toId = connection.getTo().split("-")[0];if (!deviceOrder.contains(fromId)) {deviceOrder.add(fromId);}if (!deviceOrder.contains(toId)) {deviceOrder.add(toId);}}for (String id : deviceOrder) {if (controlDevices.containsKey(id)) {System.out.println(controlDevices.get(id));} else if (controlledDevices.containsKey(id)) {System.out.println(controlledDevices.get(id));}}}public Map<String, ControlDevice> getControlDevices() {return controlDevices;}public Map<String, ControlledDevice> getControlledDevices() {return controlledDevices;}
}class Connection {private String from;private String to;public Connection(String from, String to) {this.from = from;this.to = to;}public String getFrom() {return from;}public String getTo() {return to;}
}abstract class ControlDevice {protected int inputVoltage;protected int outputVoltage;public void setInputVoltage(int voltage) {this.inputVoltage = voltage;calculateOutputVoltage();}public int getOutputVoltage() {return outputVoltage;}protected abstract void calculateOutputVoltage();public abstract String getId();@Overridepublic abstract String toString();
}class Switch extends ControlDevice {private boolean isClosed = false;public void toggle() {isClosed = !isClosed;calculateOutputVoltage();}@Overrideprotected void calculateOutputVoltage() {outputVoltage = isClosed ? inputVoltage : 0;}@Overridepublic String getId() {return "K1";}@Overridepublic String toString() {return "@K1:" + (isClosed ? "closed" : "turned on");}
}class SteppedSpeedController extends ControlDevice {private int level = 0;public void increaseLevel() {if (level < 3) {level++;calculateOutputVoltage();}}public void decreaseLevel() {if (level > 0) {level--;calculateOutputVoltage();}}@Overrideprotected void calculateOutputVoltage() {outputVoltage = inputVoltage * (level + 1) / 3;}@Overridepublic String getId() {return "F1";}@Overridepublic String toString() {return "@F1:" + level;}
}class ContinuousSpeedController extends ControlDevice {private double level = 0.0;public void setLevel(double level) {this.level = level;calculateOutputVoltage();}@Overrideprotected void calculateOutputVoltage() {outputVoltage = (int) (inputVoltage * level);}@Overridepublic String getId() {return "L1";}@Overridepublic String toString() {return String.format("@L1:%.2f", level);}
}abstract class ControlledDevice {protected int brightnessOrSpeed;public abstract void setVoltage(int voltage);@Overridepublic abstract String toString();
}class IncandescentLamp extends ControlledDevice {@Overridepublic void setVoltage(int voltage) {if (voltage < 80) {brightnessOrSpeed = 0;} else if (voltage > 150) {brightnessOrSpeed = 360;} else {brightnessOrSpeed = (int) (80 + (280.0 / 70.0) * (voltage - 80));}}@Overridepublic String toString() {return "@D2:" + brightnessOrSpeed;}
}class FluorescentLamp extends ControlledDevice {@Overridepublic void setVoltage(int voltage) {if (voltage >= 0 && voltage <= 9) {brightnessOrSpeed = 0;} else {brightnessOrSpeed = (int) ((voltage - 10.0) / 210.0 * 200);brightnessOrSpeed = Math.min(200, Math.max(0, brightnessOrSpeed)); // 限制在0-200之间}}@Overridepublic String toString() {return "@B2:" + brightnessOrSpeed;}
}class CeilingFan extends ControlledDevice {@Overridepublic void setVoltage(int voltage) {brightnessOrSpeed = voltage == 0 ? 0 : 180;}@Overridepublic String toString() {return "@R2:" + brightnessOrSpeed;}
}点击查看代码
+--------------------+ +-----------------+
| Circuit | 1 * | ControlDevice |
+--------------------+-------------------+-----------------+
| - controlDevices | | - inputVoltage |
| - controlledDevices| | - outputVoltage |
| - connections | +-----------------+
| - affectedDevices | | + setInputVoltage(int) |
+--------------------+ | + getOutputVoltage() |
| + addControlDevice(id, device) | + calculateOutputVoltage() (abstract) |
| + addControlledDevice(id, device) | + getId() (abstract) |
| + addConnection(connection) | + toString() (abstract) |
| + applyAdjustments(adjustments) +-----------------+
| + calculateOutputs() |
| + printResults() |
| + getControlDevices() |
| + getControlledDevices() |
+--------------------+ +---------------------+/| SteppedSpeedController |/ +---------------------+/ | - level |/ +---------------------+1 * / | + increaseLevel() |
+--------------------+-------------/-----| + decreaseLevel() |
| ControlledDevice | / +---------------------+
+--------------------+ / | + calculateOutputVoltage() |
| - brightnessOrSpeed | / | + getId() |
+--------------------+ / | + toString() |
| + setVoltage(int) (abstract) / +---------------------+
| + toString() (abstract) / +------------------------+
+------------------------------+ | ContinuousSpeedController |+------------------------+| - level |+------------------------+| + setLevel(double) || + calculateOutputVoltage() || + getId() || + toString() |+------------------------++----------------------+
| Switch |
+----------------------+
| - isClosed |
+----------------------+
| + toggle() |
| + calculateOutputVoltage() |
| + getId() |
| + toString() |
+----------------------++----------------------+
| IncandescentLamp |
+----------------------+
| + setVoltage(int) |
| + toString() |
+----------------------++----------------------+
| FluorescentLamp |
+----------------------+
| + setVoltage(int) |
| + toString() |
+----------------------++----------------------+
| CeilingFan |
+----------------------+
| + setVoltage(int) |
| + toString() |
+----------------------++----------------------+
| Connection |
+----------------------+
| - from |
| - to |
+----------------------+
| + getFrom() |
| + getTo() |
+----------------------++----------------------+
| Main |
+----------------------+
| |
+----------------------+踩坑心得
/1硬编码的设备ID：代码中设备ID是硬编码的，例如Switch的getId方法总是返回"K1"。如果后续添加更多设备，可能会造成冲突。改进建议：可以在构造函数中传递设备ID，并在每个设备实例化时动态赋值。/2输入电压的硬编码：控制设备的输入电压被硬编码为220V，在main方法中直接设置。改进建议：可以通过配置文件或参数传递输入电压，以便更灵活地调整。/3连接关系处理的简化：连接关系通过字符串解析from和to来建立，假设连接关系总是有效且格式正确。改进建议：增加对连接关系的验证，确保from和to的设备ID存在，并且格式正确。/4调整命令的格式和处理：调整命令的解析依赖于字符串位置和特定格式，例如adjustment.substring(1, 3)。改进建议：可以引入正则表达式或更健壮的解析方法，确保格式正确并提供友好的错误提示。/5连接关系的输出顺序：结果输出顺序依赖于连接关系的顺序，如果输入顺序变化，输出结果顺序也会变化，可能导致结果不一致。改进建议：可以对设备进行拓扑排序，确保输出顺序与逻辑关系一致。第六次作业
智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。以下题目介绍中加粗的部分为本次迭代在“家居强电电路模拟程序-1”的基础上增加的功能要求。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。控制设备的输入引脚编号为1，输出引脚编号为2。
所有开关的电阻为 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。本次迭代模拟一种落地扇。工作电压区间为 [80V,150V]，对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分 钟，[100-120)V 区间对应转速为 160 转/分钟，[120-140)V 区间对应转速为 260 转/分钟，超过 140V 转速 为 360 转/分钟（本次迭代暂不考虑电压超标的异常情况）输入信息：本次迭代考虑电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落 地扇的电阻为 203、输入信息1）输入设备信息分别用设备标识符K、F、L、B、R、D、A分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇。设备标识用标识符+编号表示，如K1、F3、L2等。引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。约束条件：不同设备的编号可以相同。
同种设备的编号可以不连续。设备信息不单独输入，包含在连接信息中。2）输入连接信息一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。约束条件：不考虑调速器串联到其他调速器的情况。
不考虑调速器串联到其他调速器的情况。
考虑各类设备的并联接入。例如，K1 的输出接到 L2 的输入，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。5）输入串联电路信息一条串联电路占一行，串联电路由按从靠电源端到接地端顺序依次输入的 n 个连接 信息组成，连接信息之间用英文空格" "分隔。串联电路信息格式："#T"+电路编号+":"+连接信息+" "+连接信息+...+" "+连接信息
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一个串联电路的第一个引脚是 IN，代表起始端，靠电源。最后一个引脚是 OUT，代表结尾端， 靠接地。 约束条件：不同的串联电路信息编号不同。
输入的最后一条电路信息必定是总电路信息，总电路信息的起始引脚是 VCC，结束引脚是 GND。
连接信息中的引脚可能是一条串联或并联电路的 IN 或者 OUT。例如：
#T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]
#T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT] 6）输入并联电路信息一条并联电路占一行，并联电路由其包含的几条串联电路组成，串联电路标识之间用英文空格" "分隔。格式："#M"+电路编号+":"+”[”+串联电路信息+" "+....+" "+串联电路信息+”]”
例如：#M1:[T1 T2 T3]
该例声明了一个并联电路，由 T1、T2、T3 三条串联电路并联而成，三条串联电路的 IN 短 接在一起构成 M1 的 IN，三条串联电路的 OUT 短接在一起构成 M1 的 OUT。 约束条件：本次迭代不考虑并联电路中包含并联电路的情况，也不考虑多个并联电路串联的情况。本题不考虑输入电压或电压差超过220V的情况。输入信息以end为结束标志，忽略end之后的输入信息。本题中的并联信息所包含的串联电路的信息都在并联信息之前输入，不考虑乱序输入的情况。
电路中的短路如果不会在电路中产生无穷大的电流烧坏电路，都是合理情况，在本题测试点的考虑范围之内。本题不考虑一条串联电路中包含其他串联电路的情况。例如：#T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]
本例中T1\T2两条串联电路实际是T3的一个部分，本题不考虑这种类型的输入，而是当将T1\T2的所有连接信息直接包含在T3中定义。
下次迭代中需要考虑这种类型的输入。4、输出信息：按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.605、家居电路模拟系列所有题目的默认规则：1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。
分析思路
1、主类 Main，包含程序入口和设备管理逻辑
点击查看代码
import java.util.*;
class Main {static Map<String, Device> devices = new LinkedHashMap<>();public static void main(String[] args) {Scanner scanner = new Scanner(System.in);String input;while (!(input = scanner.nextLine()).equals("end")) {if (input.startsWith("#T") || input.startsWith("#M")) {// 处理电路连接部分，此处未实现} else if (input.startsWith("#K")) {String id = input.substring(1);Switch sw = (Switch) devices.get(id);sw.state = sw.state == 0 ? 1 : 0;} else if (input.startsWith("#F")) {String id = input.substring(1, input.length() - 1);DiscreteSpeedController dsc = (DiscreteSpeedController) devices.get(id);if (input.endsWith("+")) dsc.increaseSpeed();else dsc.decreaseSpeed();} else if (input.startsWith("#L")) {String id = input.split(":")[0].substring(1);double speed = Double.parseDouble(input.split(":")[1]);ContinuousSpeedController csc = (ContinuousSpeedController) devices.get(id);csc.setSpeed(speed);}}printStates();}static {devices.put("K1", new Switch("K1"));devices.put("K2", new Switch("K2"));devices.put("L1", new ContinuousSpeedController("L1"));devices.put("D1", new IncandescentLamp("D1"));devices.put("D2", new FluorescentLamp("D2"));devices.put("D3", new IncandescentLamp("D3"));}static void printStates() {for (String id : Arrays.asList("K1", "K2", "L1", "D1", "D2", "D3")) {if (devices.containsKey(id)) {System.out.println("@" + id + ":" + devices.get(id).getState());}}}
}
点击查看代码
class Device {String id;int state;public Device(String id) {this.id = id;this.state = 0;}public String getState() {return "";}
}
点击查看代码
class Switch extends Device {public Switch(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "turned on" : "closed";}
}点击查看代码
class DiscreteSpeedController extends Device {private static final double[] SPEEDS = {0.0, 0.3, 0.6, 0.9};public DiscreteSpeedController(String id) {super(id);}public void increaseSpeed() {if (this.state < SPEEDS.length - 1) {this.state++;}}public void decreaseSpeed() {if (this.state > 0) {this.state--;}}@Overridepublic String getState() {return String.valueOf((int)(SPEEDS[this.state] * 220));}
}
点击查看代码
class ContinuousSpeedController extends Device {double speed;public ContinuousSpeedController(String id) {super(id);this.speed = 0.0;}public void setSpeed(double speed) {this.speed = speed;}@Overridepublic String getState() {return String.format("%.2f", this.speed);}
}
点击查看代码
class IncandescentLamp extends Device {public IncandescentLamp(String id) {super(id);}@Overridepublic String getState() {int voltage = this.state;if (voltage == 0) return "0";double brightness = Math.min(200, (double) voltage / 220 * 200);return String.valueOf((int) brightness);}
}
点击查看代码
class FluorescentLamp extends Device {public FluorescentLamp(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "0" : "180";}
}
点击查看代码
class CeilingFan extends Device {public CeilingFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state > 150) return "360";return String.valueOf(80 + (this.state - 80) * 280 / 70);}
}
点击查看代码
class PedestalFan extends Device {public PedestalFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state >= 80 && this.state <= 99) return "80";if (this.state >= 100 && this.state <= 119) return "160";if (this.state >= 120 && this.state <= 139) return "260";return "360";}
}
点击查看代码
import java.util.*;class Device {String id;int state;public Device(String id) {this.id = id;this.state = 0;}public String getState() {return "";}
}class Switch extends Device {public Switch(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "turned on" : "closed";}
}class DiscreteSpeedController extends Device {private static final double[] SPEEDS = {0.0, 0.3, 0.6, 0.9};public DiscreteSpeedController(String id) {super(id);}public void increaseSpeed() {if (this.state < SPEEDS.length - 1) {this.state++;}}public void decreaseSpeed() {if (this.state > 0) {this.state--;}}@Overridepublic String getState() {return String.valueOf((int)(SPEEDS[this.state] * 220));}
}class ContinuousSpeedController extends Device {double speed;public ContinuousSpeedController(String id) {super(id);this.speed = 0.0;}public void setSpeed(double speed) {this.speed = speed;}@Overridepublic String getState() {return String.format("%.2f", this.speed);}
}class IncandescentLamp extends Device {public IncandescentLamp(String id) {super(id);}@Overridepublic String getState() {int voltage = this.state;if (voltage == 0) return "0";double brightness = Math.min(200, (double) voltage / 220 * 200);return String.valueOf((int) brightness);}
}class FluorescentLamp extends Device {public FluorescentLamp(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "0" : "180";}
}class CeilingFan extends Device {public CeilingFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state > 150) return "360";return String.valueOf(80 + (this.state - 80) * 280 / 70);}
}class PedestalFan extends Device {public PedestalFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state >= 80 && this.state <= 99) return "80";if (this.state >= 100 && this.state <= 119) return "160";if (this.state >= 120 && this.state <= 139) return "260";return "360";}
}class Main {static Map<String, Device> devices = new LinkedHashMap<>();public static void main(String[] args) {Scanner scanner = new Scanner(System.in);String input;while (!(input = scanner.nextLine()).equals("end")) {if (input.startsWith("#T") || input.startsWith("#M")) {// This section would handle circuit connections, which we are not implementing now} else if (input.startsWith("#K")) {String id = input.substring(1);Switch sw = (Switch) devices.get(id);sw.state = sw.state == 0 ? 1 : 0;} else if (input.startsWith("#F")) {String id = input.substring(1, input.length() - 1);DiscreteSpeedController dsc = (DiscreteSpeedController) devices.get(id);if (input.endsWith("+")) dsc.increaseSpeed();else dsc.decreaseSpeed();} else if (input.startsWith("#L")) {String id = input.split(":")[0].substring(1);double speed = Double.parseDouble(input.split(":")[1]);ContinuousSpeedController csc = (ContinuousSpeedController) devices.get(id);csc.setSpeed(speed);}}printStates();}static {devices.put("K1", new Switch("K1"));devices.put("K2", new Switch("K2"));devices.put("L1", new ContinuousSpeedController("L1"));devices.put("D1", new IncandescentLamp("D1"));devices.put("D2", new FluorescentLamp("D2"));devices.put("D3", new IncandescentLamp("D3"));}static void printStates() {for (String id : Arrays.asList("K1", "K2", "L1", "D1", "D2", "D3")) {if (devices.containsKey(id)) {System.out.println("@" + id + ":" + devices.get(id).getState());}}}
}点击查看代码
+-----------------------------+| Device |+-----------------------------+| - id: String || - state: int |+-----------------------------+| + getState(): String |+-----------------------------+^|+-------------------------+----------------------------------+| | |v v v
+----------------+ +----------------------------+ +-------------------------+
| Switch | | DiscreteSpeedController | | ContinuousSpeedController|
+----------------+ +----------------------------+ +-------------------------+
| + getState() | | + increaseSpeed() | | - speed: double |
+----------------+ | + decreaseSpeed() | +-------------------------+| + getState() | | + setSpeed(double) |+----------------------------+ | + getState() |+---------------------------++----------------------+---------------------+----------------------+| | | |v v v v
+-------------------+ +-------------------+ +-------------------+ +-------------------+
| IncandescentLamp | | FluorescentLamp | | CeilingFan | | PedestalFan |
+-------------------+ +-------------------+ +-------------------+ +-------------------+
| + getState() | | + getState() | | + getState() | | + getState() |
+-------------------+ +-------------------+ +-------------------+ +-------------------+ 1、Device 是一个基类，所有设备类都继承自它。2、Switch, DiscreteSpeedController, ContinuousSpeedController, IncandescentLamp, FluorescentLamp, CeilingFan, 和 PedestalFan 都继承自 Device。
反思总结
这段代码有点考虑不周全，虽然是把作业完成了，但实际用下来还有漏洞
1.类型转换的安全性：代码中存在强制类型转换，如果类型不匹配会抛出ClassCastException。改进：使用instanceof进行类型检查，确保安全转换。2.Magic Numbers：代码中存在很多未说明含义的常量，例如电压、亮度等。改进：定义常量或枚举来表示这些数值，使代码更具可读性和可维护性。3.方法命名和职责分离：Main类中存在处理输入和打印状态的混合逻辑。改进：将输入处理和状态打印分离到独立的方法或类中。4.缺少输入验证：输入处理没有对输入格式和内容进行验证，可能导致错误。改进：增加输入验证，确保输入格式和内容的合法性。
改进后的代码
点击查看代码
import java.util.*;abstract class Device {String id;int state;public Device(String id) {this.id = id;this.state = 0;}public abstract String getState();
}class Switch extends Device {public Switch(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "turned on" : "closed";}
}class DiscreteSpeedController extends Device {private static final double[] SPEEDS = {0.0, 0.3, 0.6, 0.9};public DiscreteSpeedController(String id) {super(id);}public void increaseSpeed() {if (this.state < SPEEDS.length - 1) {this.state++;}}public void decreaseSpeed() {if (this.state > 0) {this.state--;}}@Overridepublic String getState() {return String.valueOf((int)(SPEEDS[this.state] * 220));}
}class ContinuousSpeedController extends Device {double speed;public ContinuousSpeedController(String id) {super(id);this.speed = 0.0;}public void setSpeed(double speed) {this.speed = speed;}@Overridepublic String getState() {return String.format("%.2f", this.speed);}
}class IncandescentLamp extends Device {private static final int MAX_BRIGHTNESS = 200;private static final int MAX_VOLTAGE = 220;public IncandescentLamp(String id) {super(id);}@Overridepublic String getState() {int voltage = this.state;if (voltage == 0) return "0";double brightness = Math.min(MAX_BRIGHTNESS, (double) voltage / MAX_VOLTAGE * MAX_BRIGHTNESS);return String.valueOf((int) brightness);}
}class FluorescentLamp extends Device {private static final int ON_BRIGHTNESS = 180;public FluorescentLamp(String id) {super(id);}@Overridepublic String getState() {return this.state == 0 ? "0" : String.valueOf(ON_BRIGHTNESS);}
}class CeilingFan extends Device {public CeilingFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state > 150) return "360";return String.valueOf(80 + (this.state - 80) * 280 / 70);}
}class PedestalFan extends Device {public PedestalFan(String id) {super(id);}@Overridepublic String getState() {if (this.state < 80) return "0";if (this.state >= 80 && this.state <= 99) return "80";if (this.state >= 100 && this.state <= 119) return "160";if (this.state >= 120 && this.state <= 139) return "260";return "360";}
}class Main {static Map<String, Device> devices = new LinkedHashMap<>();public static void main(String[] args) {initializeDevices();processInput();printStates();}private static void initializeDevices() {devices.put("K1", new Switch("K1"));devices.put("K2", new Switch("K2"));devices.put("L1", new ContinuousSpeedController("L1"));devices.put("D1", new IncandescentLamp("D1"));devices.put("D2", new FluorescentLamp("D2"));devices.put("D3", new IncandescentLamp("D3"));}private static void processInput() {Scanner scanner = new Scanner(System.in);String input;while (!(input = scanner.nextLine()).equals("end")) {try {if (input.startsWith("#T") || input.startsWith("#M")) {// 处理电路连接部分，此处未实现} else if (input.startsWith("#K")) {handleSwitchInput(input);} else if (input.startsWith("#F")) {handleDiscreteSpeedControllerInput(input);} else if (input.startsWith("#L")) {handleContinuousSpeedControllerInput(input);}} catch (Exception e) {System.out.println("Invalid input: " + input);}}}private static void handleSwitchInput(String input) {String id = input.substring(1);if (devices.get(id) instanceof Switch) {Switch sw = (Switch) devices.get(id);sw.state = sw.state == 0 ? 1 : 0;}}private static void handleDiscreteSpeedControllerInput(String input) {String id = input.substring(1, input.length() - 1);if (devices.get(id) instanceof DiscreteSpeedController) {DiscreteSpeedController dsc = (DiscreteSpeedController) devices.get(id);if (input.endsWith("+")) dsc.increaseSpeed();else dsc.decreaseSpeed();}}private static void handleContinuousSpeedControllerInput(String input) {String[] parts = input.split(":");String id = parts[0].substring(1);double speed = Double.parseDouble(parts[1]);if (devices.get(id) instanceof ContinuousSpeedController) {ContinuousSpeedController csc = (ContinuousSpeedController) devices.get(id);csc.setSpeed(speed);}}private static void printStates() {for (String id : devices.keySet()) {if (devices.containsKey(id)) {System.out.println("@" + id + ":" + devices.get(id).getState());}}}
} 1、增加了输入验证和异常处理，防止输入错误导致程序崩溃。2、使用instanceof进行类型检查，确保类型转换的安全性。3、将设备初始化和输入处理逻辑拆分为独立的方法，提高代码的可读性和维护性。4、使用常量替代魔法数，提高代码的可读性和可维护性。
总结
这三次大作业题量不多，但难度偏大，需要花费不少时间构思与搭框架，虽然没有全部满分过，但也从中学到了不少干货
设备管理系统面向对象编程（OOP）基础：学习了如何定义类和类的继承关系。学习了如何通过抽象类和多态来实现不同设备的行为。抽象类和方法重写：Device 是一个抽象类，不同类型的设备继承自 Device 并实现各自的 getState() 方法。封装和继承：通过继承实现了设备的多样性，每种设备都有自己的状态表示和行为逻辑。异常处理：在处理用户输入时，通过捕获异常来避免程序崩溃，提高了代码的健壮性。考试系统复杂对象的设计和使用：学习了如何设计更复杂的对象，如 Question、ChoiceQuestion、FillInTheBlankQuestion、TestPaper、AnswerSheet 和 Student。学习了如何在类之间建立关联，如 TestPaper 中的题目和分数映射，AnswerSheet 中的题目序号和答案映射。继承与多态：Question 类是基础类，ChoiceQuestion 和 FillInTheBlankQuestion 继承自 Question 并实现自己的 isCorrect 方法。集合的使用：通过使用 Map 和 List 来存储和管理对象，了解了 Java 集合的基本用法。数据验证与处理：在评分时进行了数据验证，确保答案和题目的有效性，并处理了题目被删除的情况。进一步学习和研究的方向设计模式：学习设计模式（如策略模式、状态模式）以提高代码的可维护性和扩展性。接口与抽象类的区别：深入理解接口与抽象类的区别和使用场景。单元测试：学习如何编写单元测试来验证代码的正确性，使用 JUnit 等测试框架。高级异常处理：学习更高级的异常处理机制，如自定义异常、异常链和日志记录。数据持久化：学习如何将数据持久化到数据库中，使用 JDBC 或 ORM 框架（如 Hibernate）。并发编程：学习 Java 并发编程，了解线程和同步机制，提高程序的性能和响应能力。项目结构和模块化：学习如何组织大型项目，将代码模块化，使用 Maven 或 Gradle 进行项目管理。性能优化：学习如何进行性能分析和优化，使用工具如 JProfiler 或 VisualVM。通过这些方向的进一步学习和研究，可以提高编写高质量 Java 程序的能力，构建更复杂、更高效的系统。
