第4到6次PTA大作业课后分析与反思 BLOG
前言
第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: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" 。
样例：
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项答卷信息与判分信息将重复输出。
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~0
6、格式错误提示信息
输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
例如：wrong format:2 #Q:2+2= #4
7、试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到，则输出”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~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
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 -> points
public 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 -> answer
public 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();
@Override
public abstract String toString();
}
5、Switch.java： 继承自 ControlDevice，表示开关设备。包含开关的状态（开/关）及其电压输出逻辑。
点击查看代码
public class Switch extends ControlDevice {
private boolean isClosed = false;
public void toggle() {
isClosed = !isClosed;
calculateOutputVoltage();
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = isClosed ? inputVoltage : 0;
}
@Override
public String getId() {
return "K1";
}
@Override
public 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();
}
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = inputVoltage * (level + 1) / 3;
}
@Override
public String getId() {
return "F1";
}
@Override
public 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();
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = (int) (inputVoltage * level);
}
@Override
public String getId() {
return "L1";
}
@Override
public String toString() {
return String.format("@L1:%.2f", level);
}
}
8、ControlledDevice.java： 抽象类，表示被控设备。包含设置电压的方法，具体设备需要实现该方法。
点击查看代码
abstract class ControlledDevice {
protected int brightnessOrSpeed;
public abstract void setVoltage(int voltage);
@Override
public abstract String toString();
}
9、IncandescentLamp.java： 继承自 ControlledDevice，表示白炽灯。根据输入电压设置亮度。
点击查看代码
public class IncandescentLamp extends ControlledDevice {
@Override
public 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));
}
}
@Override
public String toString() {
return "@D2:" + brightnessOrSpeed;
}
}
10、FluorescentLamp.java： 继承自 ControlledDevice，表示荧光灯。根据输入电压设置亮度。电压在0到9之间时亮度为0，电压在10到220之间时，亮度按比例设置，最大亮度为200。
点击查看代码
public class FluorescentLamp extends ControlledDevice {
@Override
public 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之间
}
}
@Override
public 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();
@Override
public abstract String toString();
}
class Switch extends ControlDevice {
private boolean isClosed = false;
public void toggle() {
isClosed = !isClosed;
calculateOutputVoltage();
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = isClosed ? inputVoltage : 0;
}
@Override
public String getId() {
return "K1";
}
@Override
public 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();
}
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = inputVoltage * (level + 1) / 3;
}
@Override
public String getId() {
return "F1";
}
@Override
public String toString() {
return "@F1:" + level;
}
}
class ContinuousSpeedController extends ControlDevice {
private double level = 0.0;
public void setLevel(double level) {
this.level = level;
calculateOutputVoltage();
}
@Override
protected void calculateOutputVoltage() {
outputVoltage = (int) (inputVoltage * level);
}
@Override
public String getId() {
return "L1";
}
@Override
public String toString() {
return String.format("@L1:%.2f", level);
}
}
abstract class ControlledDevice {
protected int brightnessOrSpeed;
public abstract void setVoltage(int voltage);
@Override
public abstract String toString();
}
class IncandescentLamp extends ControlledDevice {
@Override
public 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));
}
}
@Override
public String toString() {
return "@D2:" + brightnessOrSpeed;
}
}
class FluorescentLamp extends ControlledDevice {
@Override
public 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之间
}
}
@Override
public String toString() {
return "@B2:" + brightnessOrSpeed;
}
}
class CeilingFan extends ControlledDevice {
@Override
public void setVoltage(int voltage) {
brightnessOrSpeed = voltage == 0 ? 0 : 180;
}
@Override
public 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，落 地扇的电阻为 20
3、输入信息
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.60
5、家居电路模拟系列所有题目的默认规则：
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);
}
@Override
public 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--;
}
}
@Override
public 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;
}
@Override
public String getState() {
return String.format("%.2f", this.speed);
}
}
点击查看代码
class IncandescentLamp extends Device {
public IncandescentLamp(String id) {
super(id);
}
@Override
public 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);
}
@Override
public String getState() {
return this.state == 0 ? "0" : "180";
}
}
点击查看代码
class CeilingFan extends Device {
public CeilingFan(String id) {
super(id);
}
@Override
public 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);
}
@Override
public 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);
}
@Override
public 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--;
}
}
@Override
public 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;
}
@Override
public String getState() {
return String.format("%.2f", this.speed);
}
}
class IncandescentLamp extends Device {
public IncandescentLamp(String id) {
super(id);
}
@Override
public 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);
}
@Override
public String getState() {
return this.state == 0 ? "0" : "180";
}
}
class CeilingFan extends Device {
public CeilingFan(String id) {
super(id);
}
@Override
public 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);
}
@Override
public 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);
}
@Override
public 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--;
}
}
@Override
public 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;
}
@Override
public 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);
}
@Override
public 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);
}
@Override
public String getState() {
return this.state == 0 ? "0" : String.valueOf(ON_BRIGHTNESS);
}
}
class CeilingFan extends Device {
public CeilingFan(String id) {
super(id);
}
@Override
public 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);
}
@Override
public 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 程序的能力，构建更复杂、更高效的系统。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY