前言
第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 程式的能力，構建更復雜、更高效的系統。