OOP第二次Blog作业
前言
知识点
这三次程序设计的作业对于类与类之间的关系的设计要求较高，如果不能很好的设计出合理的类间关系，那么写起这个题目来无疑是这补补，那看看。所以，对于程序的大致框架设计显得十分重要。三次pta作业涉及的知识点很多，要求平时基本功要很好。在答题程序4中，家居强电电路模拟程序-1，家居强电电路模拟程序-2这三次作业中，都以继承为背景，考察了继承的相关知识，例如继承中多态的使用，方法的重写，以及子类的构造方法调用父类的无参构造进行数据的初始化等。同时，对于输入数据的解析和处理又考察了对于正则表达式的使用，利用捕获和分组对解析相应的信息进行创建对象的初始化。在保存对象数据时又考察了集合类的使用，例如ArrayList,，HashMap等数据结构的使用，对于保存的数据要求不同要选择对应的集合类进行储存，HashMap可以存储一个键值对，这就可以用来实现编号和对象一一对应的关系。
题量和难度
总的来说，题量不是很大，每周就是写一个大的pta作业，但题目的需求是越来越复杂了。不过题目是迭代的，难度在一开始不会很大，所以只要做好每一次的pta题目，那么下一次的题目也就是在上一次写好的程序中加上一些新的需求。虽然有时候类间关系的设计真的很难。我觉得这些题的难点有两个：1.在于字母合理的设计类间关系；2.在于对于题目信息的解析和处理，剩下的就是时间问题了，把这两个搞清楚了，写起程序来那自然是不在话下。
设计与分析
答题程序4
新增需求：在本题中，相对与答题程序3，新增了选择题和填空题，并且对于这两道题还引入了部分正确的情况，新增输入顺序打乱，多个学生多张答卷情况。
设计：因为出现了多种题目，所以抽取出一个题目类作为父类，让具体的题型继承题目类，在每一个子类题目中重写判断答案是否正确的isRight方法，对于一般的问答题，结果只有两种，所以只要比较标准答案和学生答案是否一致就行，对于多选题和填空题，新增了答案部分正确的情况判断，处理方法是将标准答案的字符串进行处理。基本思想通过循环遍历比较学生答案和标准答案，统计学生的子答案与标准答案匹配个数，如果出现一个不正确的，返回-1，如果匹配数量小于答案数量，部分正确，则返回2，如果匹配数量等于答案数量，返回1，最后根据返回值来计算得分。
对于题目删除顺序打乱的处理也很简单，在主函数中，先用一个ArrayList集合存储被删除题目的题号，输入完成后，在对于题目集合中被删除的题目进行标记，标记完之后在用题目集合对每张试卷的题目信息进行初始化。
然后对于多张试卷的处理，只需在答卷类中将原来的单张试卷改成用集合存储即可。
整体框架：1.在主函数中，先创建集合对象存储所有题目，试卷，答卷，学生信息，被删除的题目编号，然后解析输入数据，先对数据进行格式判断，格式错误输出对应信息，格式正确创建对象.2.输入结束后，对于集合中的数据进一步处理，标记删除的题目，对试卷中的题目初始化，对于答卷中的数据域进一步初始化.3.然后对试卷进行排序。4.输出结果。
类图：
方法：
| Method | CogC | ev(G) | iv(G) | v(G) |
|---|---|---|---|---|
| Main3.isFormat(String) | 16 | 11 | 8 | 13 |
| Main3.main(String[]) | 55 | 1 | 24 | 24 |
| Main3.sortAnswer(ArrayList |
11 | 1 | 6 | 6 |
| answer.answer() | 0 | 1 | 1 | 1 |
| answer.getMyAnswer() | 0 | 1 | 1 | 1 |
| answer.getNum() | 0 | 1 | 1 | 1 |
| answer.getP() | 0 | 1 | 1 | 1 |
| answer.getResult() | 0 | 1 | 1 | 1 |
| answer.getStuID() | 0 | 1 | 1 | 1 |
| answer.input(String) | 0 | 1 | 1 | 1 |
| answer.paperByNum(TreeMap<Integer, paper>) | 1 | 1 | 1 | 2 |
| answer.searchID(int) | 3 | 3 | 3 | 3 |
| answer.searchName(TreeMap<String, String>) | 1 | 2 | 2 | 2 |
| answer.setMyAnswer(HashMap<Integer, String>) | 0 | 1 | 1 | 1 |
| answer.setMyAnswer(String) | 1 | 1 | 2 | 2 |
| answer.setNum(String) | 1 | 1 | 2 | 2 |
| answer.setNum(int) | 0 | 1 | 1 | 1 |
| answer.setP(paper) | 0 | 1 | 1 | 1 |
| answer.setRealMyAnswer() | 4 | 2 | 3 | 4 |
| answer.setResult() | 11 | 6 | 5 | 9 |
| answer.setResult(HashMap<Integer, String>) | 0 | 1 | 1 | 1 |
| answer.setStuID(String) | 1 | 1 | 2 | 2 |
| answer.signScore(ArrayList |
10 | 2 | 8 | 9 |
| answer.sumScore(TreeMap<String, String>, ArrayList |
11 | 3 | 11 | 11 |
| paper.getNum() | 0 | 1 | 1 | 1 |
| paper.getQ() | 0 | 1 | 1 | 1 |
| paper.getScore() | 0 | 1 | 1 | 1 |
| paper.initQ(TreeMap<Integer, question>) | 1 | 1 | 2 | 2 |
| paper.input(String) | 2 | 1 | 3 | 3 |
| paper.isFull() | 1 | 1 | 1 | 2 |
| paper.isRight(String, int) | 0 | 1 | 1 | 1 |
| paper.paper() | 0 | 1 | 1 | 1 |
| question.getDetail() | 0 | 1 | 1 | 1 |
| question.getNum() | 0 | 1 | 1 | 1 |
| question.getStandardAnswer() | 0 | 1 | 1 | 1 |
| question.input(String) | 1 | 1 | 2 | 2 |
| question.isDelete() | 0 | 1 | 1 | 1 |
| question.isRight(String) | 0 | 1 | 1 | 1 |
| question.question() | 0 | 1 | 1 | 1 |
| question.setDelete(boolean) | 0 | 1 | 1 | 1 |
| questionK.isRight(String) | 9 | 6 | 3 | 6 |
| questionK.questionK() | 0 | 1 | 1 | 1 |
| questionN.isRight(String) | 1 | 2 | 1 | 2 |
| questionN.questionN() | 0 | 1 | 1 | 1 |
| questionZ.isRight(String) | 9 | 6 | 3 | 6 |
| questionZ.questionZ() | 0 | 1 | 1 | 1 |
| 类： |
| Class | OCavg | OCmax | WMC |
|---|---|---|---|
| Main3 | 13.67 | 24 | 41 |
| answer | 2.43 | 9 | 51 |
| paper | 1.5 | 3 | 12 |
| question | 1.12 | 2 | 9 |
| questionK | 3.5 | 6 | 7 |
| questionN | 1.5 | 2 | 3 |
| questionZ | 3.5 | 6 | 7 |
家居强电电路模拟程序-1
需求：这次是一个全新的题目，要求模拟简单串联电路，设备分两种：受控设备和控制设备。受控设备包括白炽灯，日光灯和吊扇，每个设备在不同的电压下都会有不同的参数状态。控制设备包括：开关，连续调速器和分档调速器，其中开关用来控制电路连通与否，调速器用来改变输入的电压值。本次题目不考虑电阻。输入信息包括连接信息和调节信息。
设计：首先定义一个设备类来储存不同设备的共同信息，包括名称，编号，输入引脚和输出引脚电压值，在父类中定义display和update方法，让子类重写这两个方法，为后续统一处理提供便利。
然后分别定义设备子类：开关类，为其新增int类型的数据成员，判断开关的状态；连续调速器和分档调速器类，为它们新增挡位数据成员来实现挡位的变化；灯类，新增亮度数据成员，来实现不同电压下的亮度变化，然后日关灯类和白炽灯类继承灯类；吊扇类，新增转速数据成员，实现不同电压下的转速变化。在受控设备中，重写update方法，功能是根据拿到的电压设置设备对象的参数，同时重写display方法，输出设备的状态参数。
最后，在主函数中，创建一个ArrayList集合储存所有的电器设备，利用正则表达式解析连接信息，根据信息创建对象，然后解析调节信息，调用对象的update方法进行更新参数。
类图：
方法：
| Method | CogC | ev(G) | iv(G) | v(G) |
|---|---|---|---|---|
| B.B() | 0.0 | 1.0 | 1.0 | 1.0 |
| B.B(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| B.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| D.D(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| D.D(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| D.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| D.getSpeeds() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.Device() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.Device(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getId() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getInput() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getName() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getOutput() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.outSubIn() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.setId(int) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.setInput(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.setName(String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.setOutput(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.update() | 0.0 | 1.0 | 1.0 | 1.0 |
| F.F(int) | 0.0 | 1.0 | 1.0 | 1.0 |
| F.F(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| F.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| F.setOutput() | 0.0 | 1.0 | 1.0 | 1.0 |
| F.update() | 0.0 | 1.0 | 1.0 | 1.0 |
| K.K() | 0.0 | 1.0 | 1.0 | 1.0 |
| K.K(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| K.getIsOpen() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.L(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| L.L(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| L.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.getCount() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.setCount(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| L.setOutput() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.update() | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.Light() | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.Light(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.Light(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.getBrightness() | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.getIsOpen() | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.setBrightness(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.setIsOpen(int) | 0.0 | 1.0 | 1.0 | 1.0 |
| R.R() | 0.0 | 1.0 | 1.0 | 1.0 |
| R.R(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| R.R(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| R.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| F.add() | 1.0 | 1.0 | 1.0 | 2.0 |
| F.sub() | 1.0 | 1.0 | 1.0 | 2.0 |
| K.display() | 1.0 | 1.0 | 1.0 | 2.0 |
| K.setIsOpen() | 1.0 | 1.0 | 1.0 | 2.0 |
| K.update() | 1.0 | 1.0 | 2.0 | 2.0 |
| Main.findNum(String) | 1.0 | 1.0 | 2.0 | 2.0 |
| B.update() | 2.0 | 1.0 | 2.0 | 2.0 |
| R.update() | 2.0 | 1.0 | 2.0 | 2.0 |
| Main.find(String, ArrayList) | 3.0 | 3.0 | 2.0 | 3.0 |
| D.update() | 4.0 | 1.0 | 1.0 | 4.0 |
| Device.init(String) | 7.0 | 1.0 | 8.0 | 8.0 |
| Main.main(String[]) | 30.0 | 1.0 | 19.0 | 19.0 |
| Total | 54.0 | 60.0 | 88.0 | 96.0 |
| Average | 0.9310344827586207 | 1.0344827586206897 | 1.5172413793103448 | 1.6551724137931034 |
类：
| Class | OCavg | OCmax | WMC |
|---|---|---|---|
| L | 1.0 | 1.0 | 7.0 |
| Light | 1.0 | 1.0 | 7.0 |
| R | 1.2 | 2.0 | 6.0 |
| B | 1.25 | 2.0 | 5.0 |
| F | 1.2857142857142858 | 2.0 | 9.0 |
| D | 1.4 | 3.0 | 7.0 |
| Device | 1.5 | 8.0 | 21.0 |
| K | 1.5 | 2.0 | 9.0 |
| Main | 8.0 | 19.0 | 24.0 |
家居强电电路模拟程序-2
新增需求：这次加入了并联的情况，还新增了一个落地扇类，还为设备加上了电阻。
设计：在上次的基础上，为设备父类新增电阻数据成员，然后在每一个子类的构造方法中为电阻成员赋予题目给定的电阻值，新增串联电路类和并联电路类继承设备父类。
首先在串联电路类中，成员变量为设备的ArrayList集合，存储一条串联电路上所有的设备，新增判断串联电路是否开路方法，即遍历设备，判断开关数量和打开的开关数量是否相等，不相等返回false，否则返回true，新增计算总电流方法，因为要计算总电流，所以定义一个接口来计算总电阻，串联电路类和并联电路类都实现这个接口，重写计算总电阻的方法，新增对于电路上的设备计算分压的方法，即遍历设备集合，调用不同设备的dy方法，在dy方法中，参数是干路中的电流，如果该设备不是并联设备，那么用电流×电阻等到电压，如果该设备是并联设备，那么遍历并联设备里面的设备，计算电压，从而实现对于每个设备分压的计算，拿到分压就可以改变设备的参数状态。
然后在并联设备中，新增一个判断并联电路是否每条路都是开路情况。
因为要实现对设备的排序，因此让设备类实现Comparable接口，同时为每一个不同的设备设计比较值数据成员，开关先输出，所以比较值为1，以此类推，重写比较方法，如果设备的比较值不同返回两设备比较值之差，如果相同，返回设备编号之差，从而实现了排序。
最后，在主函数中，创建三个集合来分别存储所有的设备，串联电路，并联电路，另外定义一个串联电路类来保存干路的设备信息，然后解析连接信息，对于类型不同的连接进行对应的解析，创建对象，然后解析调节信息，根据解析到的信息，调用方法找到该设备，然后调用改设备的调节方法改变对应设备状态。然后，调用Collections类的sort方法对设备集合排序，再调用干路电路的方法，对所有设备进行分压计算和参数变化，最后，输出结果。
类图：
方法：
| Method | CogC | ev(G) | iv(G) | v(G) |
|---|---|---|---|---|
| A.A(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| A.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| B.B(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| B.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| Connection.Connection(String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Connection.I(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Connection.add(Device) | 0.0 | 1.0 | 1.0 | 1.0 |
| D.D(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| D.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.Device() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.Device(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.dy(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getId() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.getName() | 0.0 | 1.0 | 1.0 | 1.0 |
| Device.setName(String) | 0.0 | 1.0 | 1.0 | 1.0 |
| F.F(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| F.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| F.getCount() | 0.0 | 1.0 | 1.0 | 1.0 |
| K.K(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| K.getIsOpen() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.L(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| L.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.getCount() | 0.0 | 1.0 | 1.0 | 1.0 |
| L.setCount(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.Light(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.getBrightness() | 0.0 | 1.0 | 1.0 | 1.0 |
| Light.setBrightness(double) | 0.0 | 1.0 | 1.0 | 1.0 |
| Paralle.add(Connection) | 0.0 | 1.0 | 1.0 | 1.0 |
| Paralle.getPara() | 0.0 | 1.0 | 1.0 | 1.0 |
| R.R(int, String) | 0.0 | 1.0 | 1.0 | 1.0 |
| R.display() | 0.0 | 1.0 | 1.0 | 1.0 |
| Connection.update(double) | 1.0 | 1.0 | 2.0 | 2.0 |
| F.add() | 1.0 | 1.0 | 1.0 | 2.0 |
| F.sub() | 1.0 | 1.0 | 1.0 | 2.0 |
| K.display() | 1.0 | 1.0 | 1.0 | 2.0 |
| K.setIsOpen() | 1.0 | 1.0 | 1.0 | 2.0 |
| B.dy(double) | 2.0 | 1.0 | 1.0 | 2.0 |
| Device.compareTo(Device) | 2.0 | 2.0 | 2.0 | 2.0 |
| R.dy(double) | 2.0 | 1.0 | 2.0 | 2.0 |
| Connection.getM() | 3.0 | 3.0 | 2.0 | 3.0 |
| Paralle.dy(double) | 3.0 | 1.0 | 3.0 | 3.0 |
| Paralle.isOpen() | 3.0 | 1.0 | 2.0 | 3.0 |
| D.dy(double) | 4.0 | 1.0 | 1.0 | 4.0 |
| T4.find(String, ArrayList) | 4.0 | 4.0 | 3.0 | 4.0 |
| A.dy(double) | 7.0 | 1.0 | 1.0 | 8.0 |
| Connection.isAllClose() | 7.0 | 1.0 | 4.0 | 5.0 |
| Connection.sumR() | 7.0 | 1.0 | 4.0 | 4.0 |
| Paralle.sumR() | 7.0 | 2.0 | 3.0 | 6.0 |
| Device.init(String) | 8.0 | 1.0 | 9.0 | 9.0 |
| Connection.connectionAll() | 10.0 | 3.0 | 6.0 | 8.0 |
| T4.main(String[]) | 49.0 | 4.0 | 20.0 | 20.0 |
| Total | 123.0 | 64.0 | 101.0 | 125.0 |
| Average | 2.3653846153846154 | 1.2307692307692308 | 1.9423076923076923 | 2.4038461538461537 |
类：
| Class | OCavg | OCmax | WMC |
|---|---|---|---|
| L | 1.0 | 1.0 | 4.0 |
| Light | 1.0 | 1.0 | 3.0 |
| B | 1.3333333333333333 | 2.0 | 4.0 |
| R | 1.3333333333333333 | 2.0 | 4.0 |
| F | 1.4 | 2.0 | 7.0 |
| K | 1.5 | 2.0 | 6.0 |
| D | 1.6666666666666667 | 3.0 | 5.0 |
| Device | 2.0 | 9.0 | 18.0 |
| A | 2.3333333333333335 | 5.0 | 7.0 |
| Connection | 2.625 | 5.0 | 21.0 |
| Paralle | 2.8 | 6.0 | 14.0 |
| T4 | 11.0 | 18.0 | 22.0 |
| Total | 115.0 | ||
| Average | 2.2115384615384617 | 4.666666666666667 | 9.583333333333334 |
踩坑心得
1.对用空指针的引用，没有考虑到产生空指针的情况
家居强电电路模拟程序-2
在得到并联设备的的方法中，返回值是对象，在通过返回值调用其成员方法的过程发生引用空指针
改进前的代码：
if (allConnection.getM().sumR() != 0 && allConnection.isAllClose()) {//进行电路设备状态更新allConnection.connectionAll();}
结果如下：
改进后的代码：
if (allConnection.isAllClose()){if (allConnection.getM()!=null&&allConnection.getM().sumR()!=0){allConnection.connectionAll();}allConnection.connectionAll();}
结果如下：
2.对于Collections的排序方法不熟练
答题程序4
在排序答卷信息时，自己写了一个排序的函数，经过这些天的学习后，我发现可以用更加简短的代码来实现排序，即利用Collections里面的sort方法，让答卷实现Comparable接口
改进前：
//对答卷排序//现学号，后试卷号public static void sortAnswer(ArrayList<answer> An) {for (int i = 0; i < An.size(); i++) {for (int j = i; j < An.size(); j++) {if (Integer.parseInt(An.get(i).getStuID()) > Integer.parseInt(An.get(j).getStuID())) {answer temp = An.get(i);An.set(i, An.get(j));An.set(j, temp);} else if (Integer.parseInt(An.get(i).getStuID()) == Integer.parseInt(An.get(j).getStuID())) {if (An.get(i).getNum() > An.get(j).getNum()) {answer temp = An.get(i);An.set(i, An.get(j));An.set(j, temp);}}}}}
改进后：
在答卷类中：
public int compareTo(answer o) {if (Integer.parseInt(this.getStuID()) != Integer.parseInt(o.getStuID()))return Integer.parseInt(this.getStuID()) - Integer.parseInt(o.getStuID());elsereturn this.getNum() - o.getNum();}
在主函数中：
Collectios.sort(An);
3.对于类设计的缺陷
家居强电电路模拟程序-1
在该题目中，我没有创建一个连接类模拟串联电路的效果，导致只能处理两个设备的连接情况，因此我还加了许多判断，使代码的可读性降低，因为在第一次设计中我一直在想怎么通过引脚传递电压，感觉很复杂。
代码如下：
//更新连接设备电压//更新电压之后，还要更新参数for (int i = 0; i < devices.size(); i++)devices.get(i).update();if (flag == 0)devices.get(1).setInput(devices.get(0).getOutput());for (int i = 0; i < devices.size(); i++)devices.get(i).update();//输出状态if (ks.size()!=0)for (K k : ks) {k.display();}for (int i = 0; i < devices.size(); i++) {if (!(devices.get(i) instanceof K))devices.get(i).display();}
因此我在第二次迭代的程序中加上了串联设备这个类，同时不再考虑通过引脚传递电压，直接计算每个设备的分压即可。
//连接类
class Connection extends Device implements kisAllOpen, sumR {private ArrayList<Device> sd = new ArrayList<>();public Connection(String s) {setName(s);}//连接设备public void connectionAll() {if (!isAllClose())return;if (getM()!=null&&getM().isOpen())return;Device first = sd.get(0);double initInput;if (first.getName() != null && (first.getName().equals("L") || first.getName().equals("F"))) {if (first instanceof L)initInput = ((L) first).getCount() * 100 * 220 / 100;elseinitInput = ((F) first).getCount() * 220 * 3 / 10.0;//计算总电流} elseinitInput = 220;double I = I(initInput);update(I);}//添加设备public void add(Device d) {sd.add(d);}//得到并联电路public Paralle getM() {for (Device device : sd) {if (device.getId() == 0)return (Paralle) device;}return null;}@Overridepublic boolean isAllClose() {int cnt = 0;int open = 0;for (Device value : sd) {if (value.getName() != null && value.getName().equals("K")) {cnt++;K k = (K) value;if (k.getIsOpen() == 1) {open++;}}}return cnt == open;}@Overridepublic double sumR() {double sum = 0;if (isAllClose()) {for (Device value : sd) {if (value instanceof Paralle)sum += ((Paralle) value).sumR();elsesum += value.r;}}return sum;}//计算总电流public double I(double iu) {return iu / sumR();}//拿到总电流之后遍历串联设备 调用dy方法把设备参数更新public void update(double I) {for (Device device : sd) {device.dy(I);}}
}
改进建议
1.答题程序4
对于数据的储存不仅可以通过创建类来实现，但最优的方法还是通过一些数据结构来存储题目，这样可以减少程序的复杂性，ArrayList，HashMap等，都是存储引用数据类型的好手，可以在程序中根据不同的数据需求来选择对应的数据结构来存储数据。
2.家居强电电路模拟程序-1
类之间的关系应该去仔细分析，不能为了得分而使得程序越来越臃肿，新增串联电路类，用来处理设备连接，再类中加上判断该电路是否开路的方法，如果开路，直接输出结果，否则根据电压更新设备状态。
3. 家居强电电路模拟程序-1
类的成员方法仍有改进的余地，要服从单一职责原则，每个方法不能做太多的事，可以把相同的操作抽取出来作为一个独立的方法，同时，对于类间的关系还要再仔细考虑考虑。
总结
通过这三次作业，对于面向对象编程有了进一步的了解。三次作业的难度不小，后两次作业需要自己设计类，设计成员方法和成员变量，对问题分析能力有一定的要求。在编写程序的过程中，开始逐渐的考虑类的规范设计，同时解决问题的能力逐步提高。
学到了什么：
通过这三次作业，我熟悉了集合排序的方法，以及怎么设计合理的类间关系，以及如何使用继承来实现程序的可扩展性，但在三次作业的过程中，我也发现了自己的问题，基础不是很牢靠，学习方法可能存在一些问题，我正在慢慢的改正。同时，仍需要进一步的学习java，了解设计原则，多多思考，多动手敲代码。以便日后解决需求更加复杂的程序设计。