前言
面向对象编程课程的“答题判题程序-4”作业是一个综合性的练习，旨在加深学生对面向对象编程思想的理解，并实际应用于解决复杂问题。本作业要求学生设计并实现一个答题程序，模拟小型测试的全过程，包括题目信息、试卷信息、答题信息、学生信息的输入，以及答题结果的判断和输出。
家居强电电路模拟程序-1是关于智能家居强电电路模拟程序的设计和实现，题量适中，要求学生能够综合运用所学的编程知识解决实际问题。难度方面，对于有一定编程基础和电路知识的学生来说，是具有挑战性的，但通过合理的分析和设计，可以顺利完成。
家居强电电路模拟程序-2 是一个综合性的编程任务，它要求学生设计和实现一个模拟智能家居强电电路的系统。题量适中，要求学生综合运用编程知识解决实际问题。难度方面，此任务对于有编程基础和电路知识的学生来说是具有挑战性的，但通过合理的分析和设计，可以顺利完成。
（1）知识点概述：
答题判题程序-4：
1，题目信息的输入与处理
题目信息的输入格式，包括题目编号、内容和标准答案。
题目信息的存储和处理，包括允许题目编号的缺失。
2，试卷信息的构建
如何根据试卷号和题目分值构建试卷信息。
试卷总分的警示功能，当总分不为100分时给出提示。
3，学生信息的管理
学生信息的输入格式，包括学号和姓名。
学生信息的存储和管理。
4，答卷信息的收集与评分
如何收集答卷信息，并根据标准答案进行评分。
对答卷中缺失答案和多余答案的处理。
5，删除题目信息的处理
删除题目信息的输入格式及其对答题结果的影响。
题目删除后的相关处理，包括分数计算和输出提示。
6，新增内容
选择题和填空题的输入格式和评分规则。
多张试卷信息的处理和输出顺序的变化。
家居强电电路模拟程序-1：
1，电路模拟：理解和模拟电路中的基础概念，如电压、电流、电阻和功率。
2，控制设备与受控设备：模拟开关、调速器等控制设备以及灯、风扇等受控设备的行为。
3，串联电路：设计电路连接方式，确保设备按正确的顺序连接。
4，输入处理：解析输入的设备信息、连接信息和控制指令。
5，状态更新与输出：根据电路状态更新设备参数，并输出结果。
家居强电电路模拟程序-2
1，电路模拟：理解和模拟电路中的基础概念，如电压、电流、电阻和功率。
2，控制设备与受控设备：模拟开关、调速器等控制设备以及灯、风扇等受控设备的行为。
3，串联和并联电路：设计电路连接方式，确保设备按正确的顺序和方式连接。
4，输入处理：解析输入的设备信息、连接信息和控制指令。
5，状态更新与输出：根据电路状态更新设备参数，并按要求格式输出结果。
6，新增内容
被控设备新增电阻
增加了一种新的电扇——落地扇
增加了并联电路
（2）设计与分析
答题判题程序-4：
源码分析
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
// 题目类
class Question {
private int number;
private String content;
private String standardAnswer;
private boolean isdelte=false;
public Question(int number,String content,String standardAnswer) {
this.number=number;
this.content=content;
this.standardAnswer=standardAnswer;
}
public boolean isIsdelte() {
return isdelte;
}
public void setIsdelte(boolean isdelte) {
this.isdelte = isdelte;
}
public String jugeAnswer(String answer) {
if(answer.equals(standardAnswer))
return "true";
else return "false";
}
public String getQuestion() {
return content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public int getNumber() {
return number;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public void setNumber(int number) {
this.number = number;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class Nquestion extends Question{
Nquestion(int number,String content,String standardAnswer)
{
super(number,content,standardAnswer);
}
@Override
public String jugeAnswer(String answer) {
if(answer.equals(super.getStandardAnswer()))
return "true";
else return "false";
}
}
class Zquestion extends Question{
Zquestion(int number,String content,String standardAnswer)
{
super(number,content,standardAnswer);
}
@Override
public String jugeAnswer(String answer)
{
answer=answer.toLowerCase();
String staanswer=super.getStandardAnswer().toLowerCase();
if(answer.equals(staanswer))
return "true";
else
{
String []partanswer=answer.split("");
for(int i=0;i<partanswer.length;i++)
{
if(!(staanswer.contains(partanswer[i])))
return "false";
}
return "partially correct";
}
}
}
class Kquestion extends Question{
Kquestion(int number,String content,String standardAnswer)
{
super(number,content,standardAnswer);
}
@Override
public String jugeAnswer(String answer)
{
if(answer.equals(super.getStandardAnswer()))
return "true";
else if(super.getStandardAnswer().contains(answer))
return "partially correct";
else
return "false";
}
}
// 试卷类
class Exam {
private int num;
private List<Que_Score>questions;
Exam(int num)
{
this.num=num;
this.questions=new ArrayList<>();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public List<Que_Score> getQuestions() {
return questions;
}
public void setQuestions(List<Que_Score> questions) {
this.questions = questions;
}
public void Addquestion(int num,int score)
{
Que_Score que_score=new Que_Score(num,score);
questions.add(que_score);
}
public void setallquestion(List
{
for(Que_Score i:this.getQuestions())
{
for(Question j:questions)
{
if(i.getNum()==j.getNumber())
{
i.setQuestion(j);
break;
}
}
}
}
public void is100()
{
int sum=0;
for(Que_Score que:this.getQuestions())
{
sum+=que.getScore();
}
if(sum!=100)
System.out.println("alert: full score of test paper"+this.getNum()+" is not 100 points");
}
}
//有分值的题目
class Que_Score{
private int num,score;
private Question question=null;
Que_Score(int num,int score)
{
this.num=num;
this.score=score;
}
public int getNum() {
return num;
}
public Question getQuestion() {
return question;
}
public void setQuestion(Question question) {
this.question = question;
}
public void setNum(int num) {
this.num = num;
}
public int getScore() {
return score;
}
public int getGetscore(String result)
{
if(result.equals("true"))
return this.score;
else if(result.equals("false"))
return 0;
else
return (this.score)/2;
}
public void setScore(int score) {
this.score = score;
}
public String checkanswer(String answer)
{
return this.question.jugeAnswer(answer);
}
}
//学生类
class Student{
private String sid,name;
Student(String sid,String name)
{
this.sid=sid;
this.name=name;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 答卷类
class AnswerSheet {
private Exam exam=null;
private int num;
private String sid;
private List<Ans_Que>ans_ques;
private List<Result_getscore>res_gscores;
AnswerSheet(){
}
AnswerSheet(int num,String sid)
{
this.num=num;
this.sid=sid;
this.ans_ques=new ArrayList<>();
this.res_gscores=new ArrayList<>();
}
public List<Result_getscore> getRes_gscores() {
return res_gscores;
}
public void setRes_gscores(List<Result_getscore> res_gscores) {
this.res_gscores = res_gscores;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public Exam getExam() {
return exam;
}
public void setExam(Exam exam) {
this.exam = exam;
}
public List<Ans_Que> getAns_ques() {
return ans_ques;
}
public void setAns_ques(List<Ans_Que> ans_ques) {
this.ans_ques = ans_ques;
}
public void Addans_que(int num,String answer) {
Ans_Que ans_que=new Ans_Que(num,answer);
this.ans_ques.add(ans_que);
}
public Student getStudent(List<Student>stu) {
for (Student student : stu) {
if (student.getSid().equals(this.getSid())) {
return student;
}
}
return new Student("", ""); // 返回一个默认的学生对象
}
public void addans_que(int num)
{
if(ans_ques.size()<exam.getQuestions().size())
{
for(int i=ans_ques.size();i<exam.getQuestions().size();i++)
{
Ans_Que ans=new Ans_Que(0,null);
ans_ques.add(ans);
}
}
}
public int testpaper_is_exist()
{
int f=0;
if(exam==null)
{
f=1;
System.out.println("The test paper number does not exsit");
}
return f;
}
public void checkanswer()
{
for(int i=0;i<this.exam.getQuestions().size();i++)
{
int flag=0;
for(Ans_Que j:this.getAns_ques())
{
if(j.getNum()==i+1)
{
flag=1;
break;
}
}
if(flag==0)
{
Result_getscore r_gs=new Result_getscore("answer is null",0);
this.res_gscores.add(r_gs);
}
else if(flag==1)
{
if(exam.getQuestions().get(i).getQuestion()==null)
{
/*for(Ans_Que j:this.getAns_ques())
{
int flag1=0;
if(j.getNum()==exam.getQuestions().get(i).getNum())
{
String ans=j.getAnswer();
Result_getscore r_gs=new Result_getscore("non-existent question~"+0,0);
this.res_gscores.add(r_gs);
flag1=1;
break;
}
}
if(flag==0)
{*/
Result_getscore r_gs=new Result_getscore("non-existent question~"+0,0);
this.res_gscores.add(r_gs);
}
else if(exam.getQuestions().get(i).getQuestion().isIsdelte())
{
Result_getscore r_gs=new Result_getscore("the question "+exam.getQuestions().get(i).getQuestion().getNumber()+" invalid~0",0);
this.res_gscores.add(r_gs);
}
else
{
for(Ans_Que j:this.getAns_ques())
{
if(j.getNum()==i+1)
{
String result=exam.getQuestions().get(i).checkanswer(j.getAnswer());
int getscore=exam.getQuestions().get(i).getGetscore(result);
result=exam.getQuestions().get(i).getQuestion().getContent()+"~"+j.getAnswer()+"~"+exam.getQuestions().get(i).checkanswer(j.getAnswer());
Result_getscore r_gs=new Result_getscore(result,getscore);
this.res_gscores.add(r_gs);
break;
}
}
}
}
}
}
public void printend1()
{
for(int i=0;i<this.exam.getQuestions().size();i++)
{
if(this.getRes_gscores().get(i).getResult().equals("answer is null"))
{
System.out.println(this.getRes_gscores().get(i).getResult());
continue;
}
else if(this.getRes_gscores().get(i).getResult().contains("non-existent question"))
{
System.out.println(this.getRes_gscores().get(i).getResult());
continue;
}
else if(this.getRes_gscores().get(i).getResult().contains("the question"))
{
System.out.println(this.getRes_gscores().get(i).getResult());
continue;
}
else
{
System.out.println(this.getRes_gscores().get(i).getResult());
}
}
}
public void printend2(List<Student>students)
{
int t=0,sum=0;
for(Student i:students)
{
if(i.getSid().equals(this.getSid()))
{
t=1;
System.out.print(i.getSid()+" "+i.getName()+":");
break;
}
}
if(t==1)
{
for(Result_getscore j:this.getRes_gscores())
{
sum+=j.getGetscore();
System.out.print(" "+j.getGetscore());
}
System.out.println("~"+sum);
}
else if(t==0)
{
System.out.println(this.getSid()+" not found");
}
}
}
//答卷题目类
class Ans_Que{
private int num;
private String answer=null;
Ans_Que(int num,String answer)
{
this.num=num;
this.answer=answer;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Result_getscore{
private String result;
private int getscore;
Result_getscore(String result,int getscore)
{
this.result=result;
this.getscore=getscore;
}
public String getResult() {
return result;
}
public void setResult(String result) {
this.result = result;
}
public int getGetscore() {
return getscore;
}
public void setGetscore(int getscore) {
this.getscore = getscore;
}
}
//输入类
class Input{
private List
private List
private List
private List
private List
private List
public void Addinformation(String str){
Pattern pattern1=Pattern.compile("#N:\s(\d+)\s#Q:\s([^#]+)\s#A:(\S+)");//N题目
Pattern pattern2=Pattern.compile("#T:\s(\d+)\s([\d]+-[\d]+\s)+");//试卷
Pattern pattern3=Pattern.compile("#X:([\d]+\s[\w]+-)+");//学生
Pattern pattern4=Pattern.compile("#S:\s(\d+)\s(\d+)\s(#A:[\d]+\s-\s[\d]\s)+");//答卷
Pattern pattern5=Pattern.compile("#D:N-\s(\d+)\s");//删除
Pattern pattern6=Pattern.compile("#Z:\s(\d+)\s#Q:\s([#]+)\s*#A:\s*([#]+)\s");//Z题目
Pattern pattern7=Pattern.compile("#K:\s(\d+)\s#Q:\s([#]+)\s*#A:\s*([#]+)\s");//K题目
Matcher matcher1=pattern1.matcher(str);
Matcher matcher2=pattern2.matcher(str);
Matcher matcher3=pattern3.matcher(str);
Matcher matcher4=pattern4.matcher(str);
Matcher matcher5=pattern5.matcher(str);
Matcher matcher6=pattern6.matcher(str);
Matcher matcher7=pattern7.matcher(str);
if(matcher1.find())
this.addNquestion(Integer.parseInt(matcher1.group(1)),matcher1.group(2).trim(),matcher1.group(3).trim());
else if(matcher2.find())
this.addExam(Integer.parseInt(matcher2.group(1)), str);
else if(matcher3.find())
this.addStudent(str);
else if(matcher4.find())
this.addAnswersheet(Integer.parseInt(matcher4.group(1)),matcher4.group(2).trim(), str);
else if(matcher5.find())
this.adddelete(Integer.parseInt(matcher5.group(1)));
else if(matcher6.find())
this.addZquestion(Integer.parseInt(matcher6.group(1)),matcher6.group(2).trim(),matcher6.group(3).trim());
else if(matcher7.find())
this.addKquestion(Integer.parseInt(matcher7.group(1)),matcher7.group(2).trim(),matcher7.group(3).trim());
else
this.addWrongstr(str);
}
public List
return questions;
}
public void setQuestions(List
this.questions = questions;
}
public List
return exams;
}
public void setExams(List
this.exams = exams;
}
public List
return students;
}
public void setStudents(List
this.students = students;
}
public List
return answersheets;
}
public void setAnswersheets(List
this.answersheets = answersheets;
}
public List
return deletes;
}
public void setDeletes(List
this.deletes = deletes;
}
public List
return wrongstr;
}
public void setWrongstr(List
this.wrongstr = wrongstr;
}
public void addNquestion(int num,String content,String Sanswer)
{
Question que=new Nquestion(num,content,Sanswer);
this.questions.add(que);
}
public void addExam(int num,String str)
{
Exam exam=new Exam(num);
Pattern pat1=Pattern.compile("(\d+)\s-\s(\d+)");
Matcher mat1=pat1.matcher(str);
while(mat1.find())
{
exam.Addquestion(Integer.parseInt(mat1.group(1)),Integer.parseInt(mat1.group(2)));
}
exams.add(exam);
}
public void addStudent(String str)
{
Pattern pat3=Pattern.compile("(\d+)\s(\w+)");
Matcher mat3=pat3.matcher(str);
while(mat3.find())
{
Student stu=new Student(mat3.group(1).trim(),mat3.group(2).trim());
this.students.add(stu);
}
}
public void addAnswersheet(int num,String sid,String str)
{
AnswerSheet ans=new AnswerSheet(num,sid);
Pattern pat2=Pattern.compile("#A:\s(\d+)\s-\s([^#]+)*");
Matcher mat2=pat2.matcher(str);
while(mat2.find())
{
ans.Addans_que(Integer.parseInt(mat2.group(1)),mat2.group(2).trim());
}
answersheets.add(ans);
}
public void adddelete(int num)
{
deletes.add(num);
}
public void addZquestion(int num,String content,String Sanswer)
{
Question que=new Zquestion(num,content,Sanswer);
this.questions.add(que);
}
public void addKquestion(int num,String content,String Sanswer)
{
Question que=new Kquestion(num,content,Sanswer);
this.questions.add(que);
}
public void addWrongstr(String str)
{
this.wrongstr.add(str);
}
}
class Output{
private Input input;
Output(Input input)
{
this.input=input;
}
public void printwrongstr()
{
for(int i=0;i<input.getWrongstr().size();i++)
System.out.println("wrong format:"+input.getWrongstr().get(i));
}
public void printis100()
{
for(int i=0;i<input.getExams().size();i++)
input.getExams().get(i).is100();
}
public void deleteque(List<Integer>deletes)
{
for(Integer i:deletes)
{
for(Question j:input.getQuestions())
{
if(j.getNumber()==i)
{
j.setIsdelte(true);
break;
}
}
}
}
public Input getInput() {
return input;
}
public void setInput(Input input) {
this.input = input;
}
public void addallQuestion()
{
for(Exam i:input.getExams())
{
i.setallquestion(input.getQuestions());
}
}
public void anssetexam()
{
for(AnswerSheet i:input.getAnswersheets())
{
for(Exam j:input.getExams())
{
if(i.getNum()==j.getNum())
{
i.setExam(j);
break;
}
}
}
}
public void sortAnswerSheets() {
List<AnswerSheet> answerSheets = input.getAnswersheets();
Collections.sort(answerSheets, new Comparator<AnswerSheet>() {
@Override
public int compare(AnswerSheet o1, AnswerSheet o2) {
int studentCompare = o1.getStudent(input.getStudents()).getSid().compareTo(o2.getStudent(input.getStudents()).getSid());
if (studentCompare != 0) {
return studentCompare;
}
return Integer.compare(o1.getNum(), o2.getNum());
}
});
}
public void printans()
{
for(AnswerSheet i:input.getAnswersheets())
{
if(i.testpaper_is_exist()==1)
{
continue;
}
else
{
i.checkanswer();
i.printend1();
i.printend2(input.getStudents());
}
}
}
}
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
String str;
Input input=new Input();
while(!((str=in.nextLine()).equals("end")))
{
input.Addinformation(str);
}
Output output=new Output(input);
output.setInput(input);
output.addallQuestion();
output.printwrongstr();
output.printis100();
output.deleteque(input.getDeletes());
output.anssetexam();
output.sortAnswerSheets();
output.printans();
in.close();
}
}
类的设计：程序中定义了多个类，如Question、Exam、Student、AnswerSheet等，每个类都有明确的职责，体现了面向对象的封装特性。
继承的应用：通过继承Question类，创建了Nquestion、Zquestion和Kquestion等子类，分别处理不同类型的题目，体现了面向对象的继承特性。
多态的利用：在Question类中定义了jugeAnswer方法，不同的子类根据题目类型具体实现该方法，体现了多态性。
心得体会
在实现过程中，深入理解了面向对象的三个基本特征：封装、继承和多态。
学会了如何根据实际问题设计合理的类结构和继承关系。
通过不断的调试和测试，提高了解决实际编程问题的能力。
家居强电电路模拟程序-1：
设计思路
设计的核心是创建一个能够模拟智能家居电路的系统。系统由多个类组成，每个类代表电路中的一个设备或概念。
import java.text.DecimalFormat;
import java.util.;
import java.util.regex.;
/*为了设计智能家居强电电路模拟系统的类框架，我们需要定义几个关键的类来表示系统中的不同组件。以下是一些基本的类设计，用于模拟控制设备和受控设备的行为：
1. 设备基类（Device）
所有设备将继承自一个基类，该基类提供了设备通用的属性和方法。/
abstract class Device {
private String id;
private double p1,p2;
public Device(String id) {
this.id = id;
this.p1=0;
this.p2=0;
// 默认电压为0V
}
public abstract void updateVoltage();
public abstract String getStatus();
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getP1() {
return p1;
}
public void setP1(double p1) {
this.p1 = p1;
}
public double getP2() {
return p2;
}
public void setP2(double p2) {
this.p2 = p2;
}
}
/### 2. 控制设备基类（ControlDevice）
控制设备基类继承自设备基类，提供了控制设备特有的属性和方法。/
abstract class ControlDevice extends Device {
public ControlDevice(String id) {
super(id);
}
// 控制设备特有的方法
}
/### 3. 开关（Switch）
开关类继承自控制设备基类，包含开关状态，并能切换状态。/
class Switch extends ControlDevice {
boolean state;
public Switch(String id) {
super(id);
this.state = false; // 默认状态为关闭
}
@Override
public void updateVoltage() {
if(state)
this.setP2(getP1());
}
@Override
public String getStatus() {
return state ? "@"+this.getId()+":"+"closed" : "@"+this.getId()+":"+"turned on";
}
public void toggle() {
state = !state;
}
}
/### 4. 分档调速器（Rheostat）
分档调速器类继承自控制设备基类，包含档位信息。/
class Rheostat extends ControlDevice {
int level; // 档位级别
public Rheostat(String id) {
super(id);
this.level = 0; // 默认档位为0
}
@Override
public void updateVoltage() {
switch(this.level)
{
case 0:this.setP2(0);break;
case 1:this.setP2(0.3this.getP1());break;
case 2:this.setP2(0.6this.getP1());break;
case 3:this.setP2(0.9this.getP1());break;
default:break;
}
// 更新电压逻辑，根据档位级别调整电压
}
@Override
public String getStatus() {
return "@"+this.getId()+":"+this.level;
}
public void increase() {
if (level < 3) level++;
}
public void decrease() {
if (level > 0) level--;
}
}
/### 5. 连续调速器（ContinuousRheostat）
连续调速器类继承自控制设备基类，包含一个连续的档位参数。/
class ContinuousRheostat extends ControlDevice {
double position; // 档位参数
public ContinuousRheostat(String id) {
super(id);
this.position = 0.0; // 默认档位参数为0.0
}
@Override
public void updateVoltage() {
this.setP2(getP1()this.position);
// 更新电压逻辑，根据档位参数调整电压
}
@Override
public String getStatus() {
DecimalFormat df = new DecimalFormat("#0.00");
return "@"+this.getId()+":"+df.format(position);
}
public void setPosition(double position) {
if(position>=0&&position<=1)
this.position = position;
}
}
/### 6. 受控设备基类（ControlledDevice）
受控设备基类继承自设备基类，提供了受控设备特有的属性和方法。/
abstract class ControlledDevice extends Device {
public ControlledDevice(String id) {
super(id);
}
// 受控设备特有的方法
}
/### 7. 白炽灯（IncandescentLight）
白炽灯类继承自受控设备基类，包含亮度信息。/
class IncandescentLight extends ControlledDevice {
private double lux;
public IncandescentLight(String id) {
super(id);
this.lux=0;
}
@Override
public void updateVoltage() {
this.setP2(getP1());
if(this.getP2()<10)
this.lux=0;
if(this.getP2()>=10&&this.getP2()<220)
this.lux=(this.getP2()-10)5/7+50;
if(this.getP2()>=220)
this.lux=200;
// 更新亮度逻辑
}
@Override
public String getStatus() {
// 返回亮度值
int lux1=(int)this.lux;
return "@"+this.getId()+":"+lux1;
}
}
/### 8. 日光灯（FluorescentLight）
日光灯类继承自受控设备基类，包含开关状态。/
class FluorescentLight extends ControlledDevice {
private int lux;
public FluorescentLight(String id) {
super(id);
this.lux = 0; // 默认状态为关闭
}
@Override
public void updateVoltage() {
this.setP2(getP1());
if(this.getP2()>0)
this.lux=180;
// 更新开关状态逻辑
}
@Override
public String getStatus() {
return "@"+this.getId()+":"+this.lux;
}
}
/### 9. 吊扇（CeilingFan）
吊扇类继承自受控设备基类，包含转速信息。/
class CeilingFan extends ControlledDevice {
private double speed;
public CeilingFan(String id) {
super(id);
this.speed = 0; // 默认转速为0
}
@Override
public void updateVoltage() {
// 更新转速逻辑
this.setP2(getP1());
if(this.getP2()<80)
this.speed=0;
else if(this.getP2()==80)
this.speed=80;
else if(this.getP2()>80&&this.getP2()<150)
{
this.speed=4this.getP1()-240;
}
else if(this.getP2()>=150)
this.speed=360;
}
@Override
public String getStatus() {
int sp=(int)this.getSpeed();
return "@"+this.getId()+":"+sp;
}
public double getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
}
/### 10. 电路系统（CircuitSystem）
电路系统类负责管理所有设备的连接和状态更新。/
class CircuitSystem {
private List
private List
CircuitSystem(){};
public void addDevice(Device device) {
this.devices.add(device);
}
public void updateAllDevices() {
for(int i=0;i<devices.size();i++)
{
devices.get(i).updateVoltage();
if(i<devices.size()-1)
{
devices.get(i+1).setP1(devices.get(i).getP2());
}
}
}
public List
return devices;
}
public void setDevices(List
this.devices = devices;
}
public List
return command;
}
public void setCommand(List
this.command = command;
}
public void performCommand(String command) {
this.command.add(command);
// 解析命令并执行相应的操作
}
public void printStatus() {
for (Device device : devices) {
System.out.println(device.getStatus());
}
}
}
class Input{
private CircuitSystem circuitSystem=new CircuitSystem();
Input(){
}
public CircuitSystem getCircuitSystem() {
return circuitSystem;
}
public void setCircuitSystem(CircuitSystem circuitSystem) {
this.circuitSystem = circuitSystem;
}
public void analysInput (String input){
if(input.startsWith("[")&&input.endsWith("]"))
{
Pattern pat1=Pattern.compile("\[([^\]]
Matcher mat1=pat1.matcher(input);
mat1.find();
String str=mat1.group(1);
if(str.startsWith("VCC"))
{
this.addVCC(str.substring(4));
}
else if(!str.endsWith("GND"))
{
String []parts2=str.split(" ");
String []parts1=parts2[1].split("-");
if(parts1[0].contains("K"))
{
Device K=new Switch(parts1[0]);
this.circuitSystem.addDevice(K);
}
else if(parts1[0].contains("F"))
{
Device F=new Rheostat(parts1[0]);
this.circuitSystem.addDevice(F);
}
else if(parts1[0].contains("L"))
{
Device L=new ContinuousRheostat(parts1[0]);
this.circuitSystem.addDevice(L);
}
else if(parts1[0].contains("B"))
{
Device B=new IncandescentLight(parts1[0]);
this.circuitSystem.addDevice(B);
}
else if(parts1[0].contains("R"))
{
Device R=new FluorescentLight(parts1[0]);
this.circuitSystem.addDevice(R);
}
else if(parts1[0].contains("D"))
{
Device D=new CeilingFan(parts1[0]);
this.circuitSystem.addDevice(D);
}
}
}
else if(input.startsWith("#"))
{
input=input.substring(1);
this.circuitSystem.performCommand(input);;
}
}
public void addVCC(String device)
{
String []parts=device.split("-");
if(parts[0].contains("K"))
{
Device K=new Switch(parts[0]);
K.setP1(220);
this.circuitSystem.addDevice(K);
}
else if(parts[0].contains("F"))
{
Device F=new Rheostat(parts[0]);
F.setP1(220);
this.circuitSystem.addDevice(F);
}
else if(parts[0].contains("L"))
{
Device L=new ContinuousRheostat(parts[0]);
L.setP1(220);
this.circuitSystem.addDevice(L);
}
else if(parts[0].contains("B"))
{
Device B=new IncandescentLight(parts[0]);
B.setP1(220);
this.circuitSystem.addDevice(B);
}
else if(parts[0].contains("R"))
{
Device R=new FluorescentLight(parts[0]);
R.setP1(220);
this.circuitSystem.addDevice(R);
}
else if(parts[0].contains("D"))
{
Device D=new CeilingFan(parts[0]);
D.setP1(220);
this.circuitSystem.addDevice(D);
}
}
}
class Output{
private Input input=new Input();
Output()
{}
public Input getInput() {
return input;
}
public void setInput(Input input) {
this.input = input;
}
public void Adjust() {
for(String command:this.input.getCircuitSystem().getCommand())
{
if(command.contains("K"))
{
for(Device device:this.input.getCircuitSystem().getDevices())
{
if(command.equals(device.getId()))
{
Switch K=(Switch)device;
K.toggle();
break;
}
}
}
else if(command.contains("F"))
{
for(Device device:this.input.getCircuitSystem().getDevices())
{
Rheostat F=(Rheostat)device;
if(command.equals(device.getId()+"+"))
{
F.increase();
}
else if(command.equals(device.getId()+"-"))
{
F.decrease();
}
break;
}
}
else if(command.contains("L"))
{
for(Device device:this.input.getCircuitSystem().getDevices())
{
String []command1=command.split("