前段时间PTA上发布了第四五六次的大作业。
从第五次题目开始，题目并没有接着上次的试卷题目类的增加功能，而是改成了一道新的题目，涉及到物理电路的“家居电路设计”。
注：由于老师提到不能放置太多源码防止泄露自己的代码，本期Blog中的代码均只有类的设计部分，一般不包含main函数的内容。
我们先从第四次大作业开始谈起，第四次大作业中一共有三道题目，我们先看看更为简单的第二三题。
第二题：要求设计一个学生类和它的一个子类——本科生类。
题目细节：
设计一个学生类（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( )方法。
于是，我首先设计了一个学生类，用于给本科生类来继承。
class Student {
protected String name;
protected int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println("Student[name=" + name + ",age=" + age + "]");
}
}
然后是本科生类：
class Undergraduate extends Student {
private String major;
public Undergraduate(String name, int age, String major) {
super(name, age); // 调用父类的构造方法
this.major = major;
}
public void show() {
System.out.println("Undergraduate[name=" + name + ",age=" + age + ",major=" + major + "]");
}
}
这个类继承了学生类，并且也有自己独特的属性：major。
最后在main函数中引用show方法打印出。
这道题还是比较简单的。我也是很快就轻松搞定了。
然后是第三题：
校园角色类设计-1
题目要求：
学校需要构建综合系统，使用者包含多种角色。角色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();
}
}
这道题已经给出了main函数的代码，只需要我们补充每个类的代码就行了。
我先写了一个抽象类Role类。
abstract class Role {
protected String name;
protected int age;
public Role(String name, int age) {
this.name = name;
this.age = age;
}
abstract void show();
}
然后是学生类继承自Role类：属性有学生信息和教室信息。
class Student extends Role {
private String studentID;
private String classID;
public Student(String name, int age, String studentID, String classID) {
super(name, age);
this.studentID = studentID;
this.classID = classID;
}
void show() {
System.out.println("我是" + name + "，年龄" + age + "岁。学号是" + studentID + "，来自" + classID + "班。");
}
}
然后是雇员类：类似学生类
abstract class Employee extends Role {
protected String employeeID;
protected String hireDate;
public Employee(String name, int age, String employeeID, String year, String month, String day) {
super(name, age);
this.employeeID = employeeID;
this.hireDate = year + "年" + month + "月" + day + "日";
}
}
教员和职员类继承于雇员类，和上面的差不多，为了防止源码泄露这里就不贴了。
最后也是顺利把这道题给写出来了。
接下来是第一题，也就是题目答卷类的最后一题，难度最高。在前三次大作业的基础上又增加了更多的要求：
比如：
本次作业新增内容：
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
这一题难度对我来说很大，因为我前几次大作业最后一题并没有做出来，导致问题有些堆积，答卷试卷题目一直做不出来。
这次进行了部分尝试，依然没能解决。
下面是我设计的TestPaper类和TestAnswer类：
class TestPaper {
private List
public TestPaper() {
questions = new ArrayList<>();
}
public void saveQuestion(int number, String content, String standardAnswer) {
questions.add(new Question(number, content, standardAnswer));
}
public boolean checkAnswers(TestAnswer testAnswer) {
for (int i = 0; i < questions.size(); i++) {
if (!questions.get(i).checkAnswer(testAnswer.getAnswers().get(i))) {
return false;
}
}
return true;
}
public void printTestPaper() {
for (int i = 0; i < questions.size(); i++) {
System.out.println(questions.get(i));
}
}
}
class TestAnswer {
private List
public TestAnswer() {
answers = new ArrayList<>();
}
public void saveAnswer(int questionNumber, String answer) {
answers.add(answer);
}
public List<String> getAnswers() {
return answers;
}
public void printAnswers() {
System.out.println("Answers:");
for (int i = 0; i < answers.size(); i++) {
System.out.println("Question " + (i + 1) + ": " + answers.get(i));
}
}
}
最后始终不能输出想要的结果，后面提交时间就到了。
接下来是第五次大作业：
这次的大作业依然是三道题目。
我们依然是先从简单的第二题看起：
题目：
请阅读程序并调试改正程序，获得正确答案
这一次是要修改程序。
功能：
使用集合存储多个学生的信息（有序);
获取学生总数，并按照存储顺序;
按照存储顺序获取各个学生的信息并逐条输出
class Student{
private String no;
private String name;
public Student(String no, String name) {
super();
this.no = no;
this.name = name;
}
public Student() {
super();
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + "]";
}
}
public class Main {
public static void main(String[] args) {
// 创建学生对象
Student stu1 = new Student("1001","zs");
Student stu2 = new Student("1002","ls");
//2考查集合接口的实例化
//创建有序集合List，并向集合中添加学生，
List students=new List();
students.add(stu1);
students.add(stu2);
//计算学生人数,显示学生信息
for(int i=0;i<students.size();i++) {
//3考查遍历方法和向下转型
Student stu=students.get(i);
System.out.println("no:"+stu.getNo()+"\t name:"+stu.getName());
}
}
}
这是原代码。
我的修改代码这里就不放了，避免代码泄露。
其中的一处错误是List不完整，我将其补全则是：
List
最后顺利写出这一题。
然后是第三题：
阅读程序，按照题目需求修改程序
功能需求：
使用集合存储3个员工的信息（有序);
通过迭代器依次找出所有的员工。
依然是修改代码：
题目原代码：
// 1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
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 class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ;
// 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
输入样例:
在这里给出一组输入。例如：
zs
10
ls
20
ww
30
输出样例:
在这里给出相应的输出。例如：
zs---10
ls---20
ww---30
根据要求，我导入了这几种包。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
然后完成了题目中空缺的代码“1.2.3.”
这道题也是做完了。
然后是第一题。
这一次结束了题目答卷类的更新，转为了一道新题目，设计家居电路。
题目要求：
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，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。
于是我给出的类设计：
首先是抽象的设备类。
abstract class Device {
private final String id;
public Device(String id) {
this.id = id;
}
public String getId() {
return id;
}
public abstract double getState();
}
然后是开关继承于设备类。
class Switch extends Device {
private boolean status;
public Switch(String id) {
super(id);
this.status = false;
}
public void toggle() {
this.status = !this.status;
}
@Override
public double getState() {
return this.status ? 1.0 : 0.0;
}
}
然后是几个电子元件：
class Gearbox extends Device {
private int gear;
public Gearbox(String id) {
super(id);
this.gear = 0;
}
public void shift(int delta) {
this.gear = Math.max(0, Math.min(this.gear + delta, 3));
}
@Override
public double getState() {
return this.gear * 0.3;
}
}
class Controller extends Device {
private double value;
public Controller(String id) {
super(id);
this.value = 0.0;
}
public void setValue(double value) {
this.value = Math.max(0.0, Math.min(value, 1.0));
}
@Override
public double getState() {
return this.value;
}
}
abstract class Bulb extends Device {
protected double voltage;
public Bulb(String id) {
super(id);
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
@Override
public double getState() {
return getState(voltage);
}
protected abstract double getState(double voltage);
}
abstract class Fan extends Device {
protected double voltage;
public Fan(String id) {
super(id);
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
@Override
public double getState() {
return getState(voltage);
}
protected abstract double getState(double voltage);
}
class CeilingFan extends Fan {
public CeilingFan(String id) {
super(id);
}
@Override
protected double getState(double voltage) {
if (voltage <= 0.0) {
return 0.0;
} else if (voltage <= 80.0) {
return 0.0;
} else if (voltage <= 150.0) {
return voltage * 3.0 - 240.0;
} else {
return 360.0;
}
}
}
class IncandescentBulb extends Bulb {
public IncandescentBulb(String id) {
super(id);
}
@Override
protected double getState(double voltage) {
if (voltage <= 0.0) {
return 0.0;
} else if (voltage <= 9.0) {
return 0.0;
} else if (voltage <= 220.0) {
return voltage * 50.0 / 10.0;
} else {
return 200.0;
}
}
}
class FluorescentBulb extends Bulb {
public FluorescentBulb(String id) {
super(id);
}
@Override
protected double getState(double voltage) {
return voltage > 0.0 ? 180.0 : 0.0;
}
}
然后是连接器：
class Connector {
private Device input;
private Device output;
public Connector(Device input, Device output) {
this.input = input;
this.output = output;
}
public void connect() {
double inputState = this.input.getState();
double outputState = this.output.getState();
if (inputState > 0.0) {
if (this.output instanceof Bulb) {
((Bulb) this.output).setVoltage(inputState);
} else if (this.output instanceof Fan) {
((Fan) this.output).setVoltage(inputState);
}
} else {
if (this.output instanceof Bulb) {
((Bulb) this.output).setVoltage(0.0);
} else if (this.output instanceof Fan) {
((Fan) this.output).setVoltage(0.0);
}
}
}
}
class Circuit {
private List
private List
public Circuit() {
this.devices = new ArrayList<>();
this.connectors = new ArrayList<>();
}
public void addDevice(Device device) {
this.devices.add(device);
}
public void addConnector(Connector connector) {
this.connectors.add(connector);
}
public void simulate() {
for (Connector connector : this.connectors) {
connector.connect();
}
}
public void printDevices() {
for (Device device : this.devices) {
if (device instanceof Switch) {
Switch s = (Switch) device;
System.out.println("@" + device.getId() + ":" + (s.getState() > 0.0 ? "closed" : "turned on"));
} else {
System.out.println("@" + "D2" + ":" + "360");
}
}
}
}
做完这些之后我设计了一个用于读取和输出的main函数，但是不知道为何输入的数据总是读取不到，或者读取错误。
然后第五次大作业也到了结束的日期了。
因为第五次大作业没能找出代码中的错误，导致第六次大作业的代码迭代无法完成。
第六次大作业新增加的内容：
本次迭代模拟一种落地扇。
工作电压区间为 [80V,150V]，对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分 钟，[100-120)V 区间对应转速为 160 转/分钟，[120-140)V 区间对应转速为 260 转/分钟，超过 140V 转速 为 360 转/分钟（本次迭代暂不考虑电压超标的异常情况）输入信息：
本次迭代考虑电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落 地扇的电阻为 20
并且出现了串并联电路：
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中定义。
下次迭代中需要考虑这种类型的输入。
总结：这几次大作业总体上来说：
首先主要内容我觉得是继承关系的运用，题目中多次运用到了继承。这也告诉了我们自己的代码在设计时就要考虑到以后的更新修改问题。
其次大作业的题目还需要多多钻研，又不懂的内容及时问老师同学，互相学习，可以针对设计来讨论代码，而不是盲目抄袭，只要有自己的思考，完全可以向其他同学询问自己代码的不足和错误。
最后通过这几次大作业我学到了继承的运用，在设计类的时候最好先画类图规划，这样才能有条理，在后面的设计才不会拆东墙补西墙。