1.前言：
知识点方面，涵盖了抽象类的定义、特点、作用，以及迭代相关的各种概念，如不同迭代器的使用等。
题量适中，能够充分检验对这些知识点的理解和掌握程度。既包括对抽象类基本概念的直接考查，也有通过实际代码情境来分析的题目，还有涉及到与迭代结合运用的综合题。
难度呈阶梯式分布。基础题目帮助巩固基本知识，中等难度题目要求对知识点有深入理解并能灵活运用，而部分难题则可能需要综合考虑多个相关概念。例如，会有要求根据具体需求设计抽象类或正确使用迭代器解决复杂问题的题目。通过这样的题目集，可以全面提升对 Java 抽象类和迭代知识的掌握，为进一步深入学习 Java 打下坚实基础。
2.设计与分析：
第四次题目集：
第一题：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。本题在答题判题程序-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=5false
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=5false
党十八大报告提出要加强()建设。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=5false
古琴在古代被称为：瑶琴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=5false
古琴在古代被称为：古筝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=5false
古琴在古代被称为：瑶琴或七弦琴true
20201103 Tom: 0 10~10
1+1=2true
古琴在古代被称为：古筝false
20201103 Tom: 8 0~8
1+1=2true
古琴在古代被称为：瑟false
20201104 Jack: 5 0~5
1+1=5false
古琴在古代被称为：七弦琴partially correct
20201104 Jack: 0 10~10
部分源码：
ArrayList<String> list = new ArrayList<>();
Scanner sc=new Scanner(System.in);
// String str=sc.nextLine();
while(sc.hasNext())
{
String str=sc.nextLine();
if ("end".equalsIgnoreCase(str)) {
break;
}
list.add(str);
}
sc.close();
int size=list.size();
Question []que=new Question[list.size()];
int n;
int t=0;
boolean qu1=true;
boolean qu2=true;
for(int i=0;i<size;i++)
{
if(list.get(i).startsWith("#N"))
{
t++;
qu1=list.get(0).contains("#Q");
qu2=list.get(1).contains("#Q");
if(list.get(i).contains("#Q")) {
String[] str1 = list.get(i).split("#N:| #Q:| #A:");
n = Integer.parseInt(str1[1].trim());
que[n - 1] = new Question(n, str1[2].trim(), str1[3].trim());
// System.out.println(str1.length);
}
else
System.out.println("wrong format:"+list.get(i));
}
}
int a1=0,a2=0,total=0;
int q1=0,q2=0;
int text0=0;
for(int i=0;i<size;i++)
{
if(list.get(i).startsWith("#T"))
{
String []str2=list.get(i).split("#T:| |-");
text0=Integer.parseInt(str2[1].trim());
q1=Integer.parseInt(str2[2].trim());
a1=Integer.parseInt(str2[3].trim());
if(str2.length==6){
a2=Integer.parseInt(str2[5].trim());
q2=Integer.parseInt(str2[4].trim());
}
total=a1+a2;
}
}
boolean t1=true;
boolean t2=true;
int ji1=0,ji2=0;
for(int i=1;i<=t;i++)
{
if(q1==i)
ji1++;
if(q2==i)
ji2++;
}
if(a1==0)
ji1++;
if(a2==0)
ji2++;
if(ji1==0)
t1=false;
if(ji2==0)
t2=false;
if(total<100)
System.out.println("alert: full score of test paper1 is not 100 points");
int del=-1;
for(int i=0;i<size;i++)
{
if(list.get(i).startsWith("#D"))
{
String []str4=list.get(i).split("#D:N-");
del=Integer.parseInt(str4[1].trim());
}
}
boolean te=true;
int b1=0,b2=0,to=0;
int text=0;
int id1=0;
for(int i=0;i<size;i++)
{
if(list.get(i).startsWith("#S"))
{
String []Ans=list.get(i).split("#S:| |#A:1-|#A:2-");
text=Integer.parseInt(Ans[1].trim());
id1=Integer.parseInt(Ans[2].trim());
if(text!=text0)
te=false;
String []Ans1=new String[t];
for(i=0;i<t;i++)
{
if(qu1==false)
i++;
Ans1[i]=que[i].Ans(Ans[2*i+4]);
if(qu1==true)
{
if (Ans1[0].compareTo("false") == 0) {
b1 = 0;
}
if (Ans1[0].compareTo("true") == 0) {
b1 = a1;
}
}
if(a2!=0&&i==1)
{
if(Ans1[1].compareTo("false")==0)
{
b2=0;
}
if(Ans1[1].compareTo("true")==0)
{
b2=a2;
}
}
to=b1+b2;
}
for (i=0;i<t;i++)
{
if(qu1==false) {
i++;
}
if(del==1||t1==false)
{
i=1;
b1=0;
to=b2;
}
if(te==true)
{
if(t1==true&&qu1==true&&del!=1) {
que[i].end();
System.out.print(Ans[2 * i + 4] + "~");
System.out.println(Ans1[i]);
}
if(t2==true&&qu2==true&&del!=2) {
que[i].end();
System.out.print(Ans[2 * i + 4] + "~");
System.out.println(Ans1[i]);
}
}
if(del==2||t2==false)
{
b2=0;
to=b1;
break;
}
}
if(qu1==false)
System.out.println("non-existent question~0");
break;
}
}
见下图代码分析：
这仅仅是我残缺的代码，由此可见，该题有着不小的难度，在这类程序中，通常会定义一系列的问题和对应的正确答案。代码可能会使用数据结构来存储这些信息，比如数组或集合。然后，程序会依次呈现问题给用户，接收用户的输入。接着，通过比较用户输入与预存的正确答案来进行判断。可能会使用条件语句来确定答案的正确性，并根据结果进行相应的提示或计分操作。还可能包含错误处理代码，以应对用户输入不合法或异常情况。例如，可能会检查输入是否为空或不符合预期格式。此外，为了提高代码的可读性和可维护性，可能会将问题和答案的管理、判断逻辑等分别封装在不同的方法中，使整体结构更加清晰。通过这样的代码设计，可以有效地实现答题判断的功能，并能够根据需求进行灵活的扩展和修改。
第二题：
设计一个学生类（Student）和它的一个子类——本科生类（Undergraduate）。要求如下：
（1）Student类有姓名（name）和年龄（age）属性，两者的访问权限为protected；一个包含两个参数的构造方法，用于给姓名和年龄属性赋值；一个show( )方法用于输出Student的属性信息，输出格式为Student[name=XXX,age=XX]。
（2）Undergraduate类增加一个专业（major）属性，该属性的访问权限为private；有一个包含三个参数的构造方法，前两个参数用于给继承的年龄和姓名属性赋值，第三个参数给专业属性赋值；一个show( )方法用于输出Undergraduate的属性信息，输出格式为Undergraduate[name=XXX,age=XXX,major=XXX]。
在测试类Main的main( )方法中，调用Student类的带参数的构造方法创建对象object1，调用Undergraduate类的带参数的构造方法创建对象object2，然后分别调用它们的show( )方法。
输入格式:
第一行从键盘输入姓名（字符串）、年龄（整数）给Student类的对象object1，中间以空格隔开。
第二行从键盘输入姓名（字符串）、年龄（整数）、专业（字符串）给Undergraduate类的对象object2，中间以空格隔开。
输出格式:
第一行输出object1的姓名、年龄，格式为：Student[name=XXX,age=XX]
第二行输出object2的姓名、年龄、专业，格式为： Undergraduate[name=XXX,age=XXX,major=XXX]
输入样例:
在这里给出一组输入。例如：
张三 12
李四 19 计算机科学与技术
输出样例:
在这里给出相应的输出，其中的标点符号为英文格式。例如：
Student[name=张三,age=12]
Undergraduate[name=李四,age=19,major=计算机科学与技术]
部分源码：
class Student
{
protected String name;
protected int age;
public Student(){}
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age=age;
}
public void show()
{
System.out.println("Student[name="+name+",age="+age+"]");
}
}
class Undergraduate extends Student
{
private String major;
public Undergraduate(){}
public Undergraduate(String name,int age,String major)
{
super(name,age);
this.major=major;
}
public void show()
{
System.out.print("Undergraduate[name=" + name + ",age=" + age + ",major=" + major + "]");
}
}
见下图代码分析：
由此可见，该题较为简易，使用的类与其关联简单，完成所需代码行数也少，主要为后面题目做铺垫
第三题：
学校需要构建综合系统，使用者包含多种角色。角色Role分两类：学生Student和雇员Employee；雇员又分为教员Faculty和职员Staff。
每个角色都有姓名、性别。学生有学号、班级。一个雇员有工号、入职日期。教员有职称。职员有职位称号。
请以如下Main类为基础，构建各个角色类，将代码补充完整。
public class Main {
public static void main(String[] args) {
Faculty fac = new Faculty("张三",32,"33006","2019","10","25","讲师");
Student stu=new Student("李四",19,"20201103","202011");
Staff sta = new Staff("王五",27,"32011","2015","06","17","教务员");
fac.show();
sta.show();
stu.show();
}
}
输入格式:
无
输出格式:
我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。
部分源码：
class Role
{
String name;
int age;
public Role(){}
public Role(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age=age;
}
}
class Student extends Role
{
String id;
String cla;
public Student(){}
public Student(String name,int age,String id,String cla)
{
super(name,age);
this.id=id;
this.cla=cla;
}
public void show()
{
System.out.println("我是"+name+"，年龄"+age+"岁。学号是"+id+"，来自"+cla+"班。");
}
}
class Employee extends Role
{
String number;
String year;
String month;
String day;
public Employee(){}
public Employee(String name,int age,String number,String year,String month,String day)
{
super(name,age);
this.number=number;
this.year=year;
this.month=month;
this.day=day;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getYear() {
return year;
}
public void setYear(String year) {
this.year = year;
}
public String getMonth() {
return month;
}
public void setMonth(String month) {
this.month = month;
}
public void setDay(String day) {
this.day = day;
}
public String getDay() {
return day;
}
}
class Faculty extends Employee
{
private String position;
public Faculty(){}
public Faculty(String name,int age,String number,String year,String month,String day,String position)
{
super(name,age,number,year,month,day);
this.position=position;
}
public void show()
{
System.out.println("我是"+name+"，年龄"+age+"岁。工号是"+number+"，"+year+"年"+month+"月"+day+"日入职。是一名教师，"+position+"职称。");
}
}
class Staff extends Employee
{
private String work;
public Staff(){}
public Staff(String name,int age,String number,String year,String month,String day,String work)
{
super(name,age,number,year,month,day);
this.work=work;
}
int month1=Integer.parseInt(month);
public void show()
{
System.out.println("我是"+name+"，年龄"+age+"岁。工号是"+number+"，"+year+"年"+month1+"月"+day+"日入职。是一名"+work+"。");
}
}
见下图代码分析：
与上题相似，题目难度并不大，主要作用是引入新的知识并使学生初步了解，方便为后续难度打下基础。
第五次题目集：
智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。
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]
#T2:[VCC T1-1] [T1-2 M1-IN] [M1-OUT D2-1] [D2-2 GND]
并联线路信息：用于记录一段并联电路所包含的所有串联电路信息。
例如：#M1:[T1 T2 T3]
3、计算方式的变化
迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。
4、电路元件的变化
每次迭代会增加1-2个新的电路元件。
图1：电路结构示意图
部分源码：
abstract class Device{
String id;
int inputPin;
int outputPin;
Device(){
}
Device(int inputPin){
this.inputPin = inputPin;
}
public abstract double outputVol(double inputVol);
}
abstract class ControlDevice extends Device{
}
class Switch extends ControlDevice{
private boolean isOn = false;
public boolean getIsOn() {
return isOn;
}
public void setIsOn(boolean isOn) {
this.isOn = isOn;
}
@Override
public double outputVol(double inputVol) {
return isOn?inputVol:0;
}
public void change() {
isOn = !isOn;
}
public String state() {
if(isOn == false)
return "turned on";
if(isOn == true)
return "closed";
return id;
}
}
class Binning extends ControlDevice{
private int lel=0;
public int getLel() {
return lel;
}
public void setLel(int lel)
{
this.lel = lel;
}
@Override
public double outputVol(double inputVol) {
double []lels = {0, 0.3 , 0.6 , 0.9 };
return (lel < lels.length)?(lels[lel] * inputVol) : 0;
}
public void increase() {
if(lel < 3)
lel++;
}
public void decrease() {
if(lel > 0)
lel--;
}
public void put() {
System.out.println("@F1:" + lel);
}
}
class Continuous extends ControlDevice{
private double speed;
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
@Override
public double outputVol(double inputVol) {
return (speed >= 0 && speed <= 1)?(speed * inputVol) : 0;
}
}
abstract class ControlledDevice extends Device{
}
//class Incandescent extends ControlledDevice{
//
//}
class Fan extends ControlledDevice{
private int fanspeed;
public int getFanspeed() {
return fanspeed;
}
public void setFanspeed(int fanspeed) {
this.fanspeed = fanspeed;
}
private double in;
public double getIn() {
return in;
}
public void setIn(double in) {
this.in = in;
}
@Override
public double outputVol(double inputVol) {
return inputVol;
}
public int zspeed(double in)
{
if(in < 80)
fanspeed = 0;
if(in >= 80 && in <= 150)
fanspeed = (int) ((in-80)*4.0+80);
if(in > 150)
fanspeed = 360;
return fanspeed;
}
}
见下图代码分析：
由图可见，仅仅部分已有299行代码，可知该题具有一定难度，首先构建家居强电电路的各个组件模型，如电线、开关、电器等。通过类的定义来表示这些不同的元素，每个类包含其特定的属性和方法。例如，电线类可能有电流、电阻等属性，以及传输电能的方法。在程序运行过程中，会根据设定的电路连接情况初始化这些组件，并模拟电流的流动和各组件的状态变化。可能会使用一些算法来计算电流分配、电压降等。通过这样的代码设计，能够较为真实地模拟家居强电电路的运行情况，为相关研究和设计提供有力支持。
第六次题目集：
智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。以下题目介绍中加粗的部分为本次迭代在“家居强电电路模拟程序-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，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。
6、家居电路模拟系列1-4题目后续迭代设计：
1）电路结构变化：
迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系
电路结构变化示意图见图1。
2）计算方式的变化
迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。
3）电路元件的变化
每次迭代会增加1-2个新的电路元件。
部分源码：
abstract class CircuitComponent {
String id;
abstract double calculateVoltage();
}
class Switch extends CircuitComponent {
boolean state;
Switch(String id, boolean initialState) {
this.id = id;
this.state = initialState;
}
void toggleState() {
this.state = !this.state;
}
@Override
double calculateVoltage() {
return state ? 220 : 0;
}
}
class Divider extends CircuitComponent {
double divisionFactor; // 0.3, 0.6, 0.9 for a 4-step divider
Divider(String id, double divisionFactor) {
this.id = id;
this.divisionFactor = divisionFactor;
}
@Override
double calculateVoltage() {
return super.calculateVoltage() * divisionFactor;
}
}
class Light extends CircuitComponent {
double brightness;
Light(String id) {
this.id = id;
}
void setBrightness(double voltage) {
this.brightness = voltage > 0 && voltage < 9 ? 0 : Math.round((voltage - 10) * 5);
}
@Override
double calculateVoltage() {
return 0;
}
}
class Fan extends CircuitComponent {
double speed;
Fan(String id) {
this.id = id;
}
void setSpeed(double voltage) {
if (voltage < 80) {
this.speed = 0;
} else if (voltage < 100) {
this.speed = 80;
} else if (voltage < 120) {
this.speed = 160;
} else if (voltage < 140) {
this.speed = 260;
} else {
this.speed = 360;
}
}
@Override
double calculateVoltage() {
return 0;
}
}
public class CircuitSimulator {
private Map<String, CircuitComponent> components = new HashMap<>();
public void parseInput(String input) {
}
public void simulateCircuit() {
}
public void outputResults() {
for (CircuitComponent component : components.values()) {
if (component instanceof Switch) {
Switch sw = (Switch) component;
System.out.println("@" + sw.id + (sw.state ? ":closed" : ":turned on"));
} else if (component instanceof Divider) {
Divider div = (Divider) component;
System.out.printf("@%s:%.2f\n", div.id, div.divisionFactor);
} else if (component instanceof Light) {
Light light = (Light) component;
System.out.println("@" + light.id + ":" + light.brightness);
} else if (component instanceof Fan) {
Fan fan = (Fan) component;
System.out.println("@" + fan.id + ":" + fan.speed);
}
}
}
见下图代码分析：
该代码中需要运用更高级的数据结构和算法来精确模拟各种复杂的电路情况。对于不同类型的电器设备，可能会有更详细的模型定义。同时，代码中会处理各种交互操作，比如开关的开合对电路的影响。还会有对异常情况的处理，如过载、短路等，以确保程序的稳定性和安全性。为了更直观地展示电路状态。代码的架构可能会更加模块化和可扩展，以方便添加新的功能和适应不同的电路场景需求。这样的高难度代码展现了更强大的模拟能力和工程价值。
首先，考虑采用分层架构。可以分为数据层，负责强电电路组件的数据定义和存储；逻辑层，专注于电路逻辑的计算和模拟；控制层，处理用户交互和指令的传递。
对于数据层，使用合适的数据结构来高效组织和管理各种组件信息，如复杂的电路拓扑结构。
在逻辑层，设计复杂的算法来精确模拟电流、电压等参数的变化，考虑多种因素如电阻、电抗等的影响。
控制层要设计良好的事件处理机制，确保用户操作能及时准确地传递到逻辑层进行处理。
3.踩坑心得：
在做题时，可能会在对电路组件的抽象和建模上出现偏差，导致不能准确地体现其特性和行为。比如对电器功率的理解不全面，影响后续的电流计算。在处理电路连接关系时，可能会出现拓扑结构定义错误，进而导致整个模拟结果不正确。在代码逻辑上，可能会忽略一些特殊情况或边界条件，像最后输出时排序错误等。对于多线程的运用可能会出现线程安全问题，导致数据不一致或程序崩溃。还有可能在算法的选择和实现上出现失误，导致计算效率低下或结果不准确。另外，在异常处理方面，可能没有充分考虑到各种潜在异常，使得程序在遇到异常情况时不能正确应对。
4.改进建议：
对我自己的代码，我有以下改进想法：首先，应注重代码的可读性和可维护性，通过合理的命名和清晰的代码结构来实现。可以增加必要的注释来解释复杂逻辑。在数据结构的选择上，要根据实际需求进行优化，以提高数据操作的效率。对于电路模拟的核心算法，要不断进行优化和验证，确保准确性和高效性。在处理多线程时，要确保线程安全。同时，要关注代码的可扩展性。
总结：
通过这类题目，我学到了很多。我更加深入地理解了 Java 中面向对象编程的概念，学会了如何更好地对复杂系统进行抽象和建模。了解了如何处理复杂的数据结构和算法来模拟实际的电路情况。
然而，我也意识到还有很多地方需要进一步学习和研究。在对电路原理的深入理解上还需加强，以便能更准确地进行程序设计。对于高级的算法和数据结构，还需要深入学习来提升程序性能。在多线程并发处理方面，还需要进一步研究。另外，在代码优化和性能调优方面的能力也有待提高，要学习如何从细节处提升程序的效率和质量。同时，还应不断将新的知识和理念融入到自己的学习和实践中，以不断完善自己对这类题目的理解和处理能力，从而能够设计出更优秀的代码。