第三次blog-编程知识

第三次blog

news/2024/7/3 21:45:11/文章来源:https://www.cnblogs.com/bokelalala/p/18275346/dongli-20240629

第三次blog感悟

随着知识越学越多，任务也越来越繁重，难度也是与日俱增，也许是时间花得还不够也不够认真导致最近的一些pta作业都完成得差强人意，我认为java的学习最重要的是写作业的认真、严谨的逻辑以及大把的时间。

nchu-software-oop-2024-上-6

本次作业题目大致内容

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分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇。
5、家居电路模拟系列所有题目的默认规则：

1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。

本次的新增难点及解决方案

本次作业增加了并联电路，不过只会出现一层并联电路。我的做法是新增了一个并联电路类，跟原来的串联电路类差不多，串联电路类中包含并联电路类的ArrayList，并联电路类中也包含串联电路类的ArrayList。（以下是我的串联电路类和并联电路类）

点击查看代码

class Series{private double U;private String name;private double I;private ArrayList<Parallel> par=new ArrayList<>();private ArrayList<controlled> ctrd=new ArrayList<>();private ArrayList<controll> ctrl=new ArrayList<>();public String getName() {return name;}public void setName(String name) {this.name = name;}public Series() {}public double getU() {return U;}public void setU(double u) {U=u;}public double getR() {double r=0;for(Parallel p:getPar()){r=r+p.getR();}for(controlled c:getCtrd()){r=r+c.getR();}return r;}public int getState() {for(controll c:getCtrl()){if(c instanceof K){K k=(K)c;if(k.getState()==0){return 0;}}}for(Parallel p:getPar()){if(p.getState()==0){return 0;}}return 1;}public double getI() {return getU()/getR();}public void setI(double i) {I=i;}public ArrayList<Parallel> getPar() {return par;}public void setPar(ArrayList<Parallel> par) {this.par = par;}public ArrayList<controlled> getCtrd() {return ctrd;}public void setCtrd(ArrayList<controlled> ctrd) {this.ctrd = ctrd;}public ArrayList<controll> getCtrl() {return ctrl;}public void setCtrl(ArrayList<controll> ctrl) {this.ctrl = ctrl;}
}
class Parallel{private double U;private String name;private double I;private ArrayList<Series> ser=new ArrayList<Series>();public String getName() {return name;}public void setName(String name) {this.name = name;}public Parallel() {}public double getU() {return getI()*getR();}public void setU(double u) {U = u;}public double getR() {double r=0;for(Series s:getSer()){if(s.getState()==1){r=r+1/s.getR();}}return 1/r;}public int getState() {int juge=0;for(Series s: getSer()){if(s.getState()==1){juge=1;break;}}return juge;}public double getI() {return I;}public void setI(double i) {I = i;}public ArrayList<Series> getSer() {return ser;}public void setSer(ArrayList<Series> ser) {this.ser = ser;}
}

本次作业新增了一个受控设备，落地扇，做法是增加一个落地扇的类，继承于受控设备类。（以下展示的是落地扇类）

点击查看代码

class A extends controlled implements Comparable<A>{@Overridepublic String getstata() {int u=(int)getU();if(u>=80&&u<=99){return "80";}else if(u>=100&&u<=119){return "160";}else if(u>=120&&u<=139){return "260";}else if(u>=140){return "360";}elsereturn "0";}public A() {}@Overridepublic int compareTo(A o) {return Integer.compare(this.getNumber(), o.getNumber());}
}

本次作业的错误分析

因为连续调速器和分段调速器都是改变电压，并且只出现在主电路的开始处。所以在定义每个用电器的电压以及计算每个用电器的电流时，要先将主电路的电压替换成经过了调速器之后的电压再进行计算。（以下是部分代码）

点击查看代码

 if (main_ser.getState() == 1) {for (controll c : main_ser.getCtrl()) {u = u - c.getU();}main_ser.setU(u);for (controlled c : main_ser.getCtrd()) {c.setI(main_ser.getI());}for (Parallel p : main_ser.getPar()) {p.setI(main_ser.getI());for (Series s : p.getSer()) {if (s.getState() == 1) {s.setU(p.getU());for (controlled c : s.getCtrd()) {c.setI(s.getI());}} else {s.setU(0);for (controlled c : s.getCtrd()) {c.setI(0);}}}}} else {main_ser.setU(0);for (controlled c : main_ser.getCtrd()) {c.setI(0);}for (Parallel p : main_ser.getPar()) {for (Series s : p.getSer()) {for (controlled c : s.getCtrd()) {c.setI(0);}}}}

最后的输出要求每个用电器按照编号的顺序输出，所以每一个用电器都要继承于comparable类，最后将所有的用电器进行分类，再进行输出（以下是部分代码）

点击查看代码

for (controll c : main_ser.getCtrl()) {if (c instanceof K) {K k = (K) c;K_list.add(k);}}for (Parallel p : main_ser.getPar()) {for (Series s : p.getSer()) {for (controll c : s.getCtrl()) {if (c instanceof K) {K k = (K) c;K_list.add(k);}}}}for (controlled c : main_ser.getCtrd()) {if (c instanceof D) {D d = (D) c;D_list.add(d);} else if (c instanceof A) {A a = (A) c;A_list.add(a);} else if (c instanceof R) {R r1 = (R) c;R_list.add(r1);} else if (c instanceof B) {B b = (B) c;B_list.add(b);}}for (Parallel p : main_ser.getPar()) {for (Series s : p.getSer()) {for (controlled c : s.getCtrd()) {if (c instanceof D) {D d = (D) c;D_list.add(d);} else if (c instanceof A) {A a = (A) c;A_list.add(a);} else if (c instanceof R) {R r1 = (R) c;R_list.add(r1);} else if (c instanceof B) {B b = (B) c;B_list.add(b);}}}}Collections.sort(K_list);Collections.sort(D_list);Collections.sort(A_list);Collections.sort(R_list);Collections.sort(B_list);

总结与展望

满分100，得分89，还剩4个测试点没过，衷心希望能够在以后的作业中把所有的测试点都列举出来，或者至少给出提示，这样我们才能知道自己哪里没有考虑到，不然就一直蒙在鼓里不会的还是不会甚至不知从何学起！！！

类图设计

nchu-software-oop-2024-上-7

大致题目新增内容

互斥开关：

互斥开关有3个引脚：1个是汇总引脚，另两个是分支引脚。

开关电路示意图如图1所示，左边是汇总引脚，编号为1；右边两个是分支引脚，右上的输出引脚为2，右下输出引脚为3。图中1、2、3引脚均可以是输入引脚，当1为输入引脚时，2、3引脚为输出引脚；1为输出引脚时，2、3引脚为输入引脚。

互斥开关只有两种状态：开关接往上面的2号引脚、接往下面的3号引脚。开关每次只能接通其中一个分支引脚，而另一个分支引脚处于断开状态。

互斥开关的默认状态为1、2引脚接通，1、3引脚断开。

图1中所示的互斥开关可以反过来接入电路，即汇总引脚接往接地端，两个分支引脚接往电源端。
image.png

图1 互斥开关

为避免短路，互斥开关设置了限流电阻，12引脚之间默认电阻为5，13引脚之间默认电阻为10。
本次迭代模拟一种受控窗帘：

受控窗帘的电路符号为S，其最低工作电压为50V，电压达到或超过50V，窗帘即可正常工作，不考虑室外光照强度和室内空间大小等因素，窗帘受室内灯光的光照强度控制。

当电路中所有灯光的光照强度总和在[0,50)lux范围内，窗帘全开；
在[50,100)lux范围内，窗帘打开比例为0.8；
在[100,200)lux范围内，窗帘打开比例为0.6；
在[200,300)lux范围内，窗帘打开比例为0.4；
在[300,400)lux范围内，窗帘打开比例为0.2；
在400lux及以上范围内，窗帘关闭。
当电压低于50V，窗帘不工作，默认为全开状态。
如果电路中没有灯或者灯全部关闭，光照强度为0，窗帘处于全开状态。
受控设备电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落地扇的电阻为 20，窗帘电阻为15。
本次迭代考虑多个并联电路串联在一起的情况。

本题考虑一条串联电路中包含其他串联电路的情况。例如：

点击查看代码

#T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2两条串联电路T3的一个部分，本题考虑这种类型的输入。
互斥开关显示1、2引脚的接通状态，接通时显示closed，断开时显示turned on。

如：

@H1:turned on

受控窗帘显示窗帘打开的百分比，如：

@S1:80%

本次的新增难点及解决方案

新增了一个互斥开关，互斥开关不论是接的是2还是3，都是有电阻的，所以我把它当成了受控设别处理，增加一个互斥开关类（以下是互斥开关类的设计）

点击查看代码

class H extends controlled implements Comparable<H>{private int state=2;//2、3@Overridepublic String getstata() {if(state==2){return "closed";}else {return  "turned on";}}public void changestate(){if(state==2){state=3;}elsestate=2;}public H(){}public int getState(){return state;}@Overridepublic int compareTo(H o) {return Integer.compare(this.getNumber(), o.getNumber());}
}

此次新增的难点还有一处是串联电路中也会包含串联电路，所以要在串联电路类中增加一个串联电路的AttayList，最后分配电压时遍历所有串联电路的ArrayList（以下是部分代码）

点击查看代码

class Series{private double U;private String name;private double I;private int H_number=0;private ArrayList<Parallel> par=new ArrayList<>();private ArrayList<Series> ser=new ArrayList<>();private ArrayList<controlled> ctrd=new ArrayList<>();private ArrayList<controll> ctrl=new ArrayList<>();public ArrayList<Series> getSer() {return ser;}public int getH_number() {return H_number;}public void setH_number(int h_number) {H_number = h_number;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Series() {}public double getU() {return U;}public void setU(double u) {U=u;}public double getR() {double r=0;for(Series s:getSer()){r=r+s.getR();}for(Parallel p:getPar()){r=r+p.getR();}for(controlled c:getCtrd()){r=r+c.getR();}/*if(H_number==2){return r+5;}else if(H_number==3){return r+10;}*/return r;}public int getState() {for(Series s:getSer()){if(s.getState()==0){return 0;}}for(controll c:getCtrl()){if(c instanceof K){K k=(K)c;if(k.getState()==0){return 0;}}}for(Parallel p:getPar()){if(p.getState()==0){return 0;}}for(controlled c:getCtrd()){if(c instanceof H){H h=(H)c;if(h.getState()!=this.getH_number()){return 0;}}}return 1;}public double getI() {return getU()/getR();}public ArrayList<Parallel> getPar() {return par;}public ArrayList<controlled> getCtrd() {return ctrd;}public ArrayList<controll> getCtrl() {return ctrl;}
}

本次作业的错误分析

互斥开关的输出看的是H-1是否接到了H-2上
受控窗帘的打开程度看的是所有光照程度，所以要求出所有的光照强度总和然后再在受控窗帘类中加入光照程度的内部变量（以下是部分代码）

点击查看代码

class S extends controlled implements Comparable<S>{private double add_light=-1;public void set_add_light(double a){add_light=a;}public S(){}@Overridepublic String getstata() {if(getU()>=50){if(add_light>=0&&add_light<50){return "100%";}else if(add_light>=50&&add_light<100){return "80%";}else if(add_light>=100&&add_light<200){return "60%";}else if(add_light>=200&&add_light<300){return "40%";}else if(add_light>=300&&add_light<400){return "20%";}else {return "0%";}}else {return "0%";}}@Overridepublic int compareTo(S o) {return Integer.compare(this.getNumber(), o.getNumber());}
}
main方法中：
double kk=0;for(R r1 :R_list){kk=kk+Double.valueOf(r1.getstata());}for(B b:B_list){kk=kk+Double.valueOf(b.getstata());}for(S s : S_list){s.set_add_light(kk);}

总结与展望

满分100，得分76，有8个测试点没过，衷心希望能够在以后的作业中把所有的测试点都列举出来，或者至少给出提示，这样我们才能知道自己哪里没有考虑到，不然就一直蒙在鼓里不会的还是不会甚至不知从何学起！！

类图设计

nchu-software-oop-2024-上-8

大致题目新增内容

1）增加管脚电压的显示

在输出每个电器的状态信息后，再依次输出该电器每个管脚的电压。（格式详见输出信息部分）

2）电流限制

电器在工作时，过大的电流会引起电器过热，从而烧坏电路。本次迭代，每个元器件都有最大电流的设置，当实时电流超过最大电流时，在该电器输出信息的最后加入提示“exceeding current limit error”，与前面的信息之间用英文空格分隔。

例如：@B1:190 68-17 exceeding current limit error

本题各类电器的最大限定电流如下：

开关20、分档调速器18、连续调速器18、白炽灯9、日光灯5、吊扇12、落地扇14、互斥开关20、受控窗帘12、二极管8。

3）短路检测

如果电路出现无穷大的电流造成短路，所有元器件信息不输出，仅输出提示“short circuit error”

4）并联电路中包含并联

本次迭代考虑并联电路中包含并联电路的情况，即构成并联电路的串联电路可以包含别的并联电路。例如如下输入的电路，并联电路M2的其中一条串联电路T4中包含了另一条并联电路M1：

点击查看代码

#T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]#M1:[T1 T2]#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]#M2:[T4 T5]

5）二极管

增加二极管元件，其电路特性为：正向导通，反向截止；其电器符号如图4所示，当电流从左至右流过时，二极管导通”conduction”，电阻为0；电流从右至左流动时，二极管截止”cutoff”，电阻无穷大，相当于开关打开。

image.png

图2 二极管符号

二极管的标识符为’P’，左侧管脚编号为1，右侧管脚编号为2。

二极管如果两端电压相等，没有电流流过，分以下两种情况输出：

1、如果两端电压为0，二极管的导通/截止状态由接入方向决定，1号引脚靠近电源则状态为导通，反之为截止。
2、如果两端电压不为0，二极管导通。

本次的新增难点及解决方案

增加了一个二极管，只能单向流通，我把它当作了受控设备，若是反向连接，则将电流改成10000（一个足够大的数），到时候判断电路的电阻时，当电阻超过了10000时就判定为是断路，（以下是部分代码）

点击查看代码

class P extends controlled implements Comparable<P>{private int state = -1;public void setstate(int a) {state = a;/////////1或者0}public int getState(){return state;}@Overridepublic String getstata() {if (state == 1) {return "conduction";} else if (state == 0) {return "cutoff";}return null;}@Overridepublic int compareTo(P o) {return Integer.compare(this.getNumber(), o.getNumber());}
}

增加了短路的测试，由于我原先的代码中有判断主电路是否是短路的方法，所以，只要调用该方法判断是否短路即可（以下是串联电路中判断该串联电路是否短路的方法）

点击查看代码

public int getState() {for(Series s:getSer()){if(s.getState()==0){return 0;}}for(controll c:getCtrl()){if(c instanceof K){K k=(K)c;if(k.getState()==0){return 0;}}}for(Parallel p:getPar()){if(p.getState()==0){return 0;}}for(controlled c:getCtrd()){if(c instanceof H){H h=(H)c;if(h.getState()!=this.getH_number()){return 0;}} else if (c instanceof P) {P p=(P)c;if(p.getState()==0)return 0;}}return 1;}

还要判断用电器的电流是否超过了最大电流设置，要先得出每个用电器的电流，每个用电器的电流都是其所在的串联电路上的电流，只要遍历每个串联电路，再遍历该串联电路上的所有用电器，并给用电器的电流赋值即可。（与第四条新增难点的示例代码在一处所以一同展示）
要想得到所有的用电器的进入前后电压，首先要知道用电器所在的串联电路的两头电压，再一个个遍历所有的用电器，逐一减去该用电器所用的电压，就可以定义该用电器的输出电压，一个难点地方是此次作业中并联电路中所包含的串联电路也会包含并联电路，串联电路所包含的串联电路中也会包含并联电路，我的解决方法是定义一个方法（递归）用于处理串联电路及其中的所有用电器，受控设备、被控设备、串联电路、并联电路都继承于一个大类totol，把他们归为一大类是因为他们都有U-in及U-out，方便后续的分配和输出（以下是分配电压、电流，递归调用的代码以及totol类的设计）

点击查看代码

double u = 220;if (main_ser.getState() == 1) {//??????if((int)main_ser.getR()==0){System.out.println("short circuit error");return;}for (controll c : main_ser.getCtrl()) {u = u - c.getU();}main_ser.setU(u);main_ser.setU_IN(220);main_ser.setU_OUT(0);double ju=220;for(total to:main_ser.getTo()){to.setII(main_ser.getI());to.setU_IN(ju);ju=ju-to.getUU();to.setU_OUT(ju);to.setII(main_ser.getI());}for(Series s: main_ser.getSer()){s.setU(main_ser.getI()*s.getR());set_series(s);}for (controlled c : main_ser.getCtrd()) {c.setI(main_ser.getI());}for (Parallel p : main_ser.getPar()) {p.setI(main_ser.getI());for (Series s : p.getSer()) {s.setU_IN(p.getU_IN());s.setU_OUT(p.getU_OUT());if (s.getState() == 1) {s.setU(p.getU());} else {s.setU(0);}set_series(s);}}} else {main_ser.setU(0);main_ser.setU_IN(220);main_ser.setU_OUT(0);double ju=main_ser.getU_IN();for(total to:main_ser.getTo()){to.setII(0);to.setU_IN(ju);if(to instanceof controlled){controlled c=(controlled) to;if(c instanceof P){if(c.getR()>1000){ju=main_ser.getU_OUT();}}}else if(to instanceof controll){controll c=(controll) to;if(c instanceof K){K k=(K)c;if(k.getState()==0){ju=main_ser.getU_OUT();}}}to.setU_OUT(ju);}for (controlled c : main_ser.getCtrd()) {c.setI(0);}for (Parallel p : main_ser.getPar()) {p.setI(0);for (Series s : p.getSer()) {s.setII(0);s.setU(0);s.setU_IN(p.getU_IN());s.setU_OUT(p.getU_OUT());set_series(s);}}for(Series s: main_ser.getSer()){s.setU(0);set_series(s);}}递归方法：public static void set_series(Series S) {//已知前后电压及电压if(S.getState()==0) {double ju=S.getU_IN();for(total to:S.getTo()){to.setII(0);to.setU_IN(ju);if(to instanceof controlled){controlled c=(controlled) to;if(c instanceof H){H h=(H)c;if(S.getH_number()!=h.getNumber()){ju=S.getU_OUT();}}else if(c instanceof P){if(c.getR()>1000){ju=S.getU_OUT();}}}else if(to instanceof controll){controll c=(controll) to;if(c instanceof K){K k=(K)c;if(k.getState()==0){ju=S.getU_OUT();}}}to.setU_OUT(ju);if(to instanceof controlled){controlled c=(controlled) to;if(c instanceof H){H h=(H)c;if(S.getH_number()==h.getState()){//链接着if(h.getWay()==1){//方式1连接h.setU_1(S.getU_IN());if(h.getState()==2){h.setU_2(S.getU_IN());}else {h.setU_3(S.getU_IN());}}else {//方式2连接h.setU_1(S.getU_OUT());if(h.getState()==2){h.setU_2(S.getU_OUT());}else {h.setU_3(S.getU_OUT());}}}else {//断开if(h.getWay()==1){//方式1if(S.getH_number()==2){h.setU_2(S.getU_OUT());}else {h.setU_3(S.getU_OUT());}}else {//方式2连接if(S.getH_number()==3){h.setU_2(S.getU_IN());}else {h.setU_3(S.getU_IN());}}}}}}for(Series s: S.getSer()){s.setI(0);set_series(s);}for (controlled c : S.getCtrd()) {c.setI(S.getI());}for (Parallel p : S.getPar()) {p.setI(S.getI());for (Series s : p.getSer()) {if (s.getState() == 1) {s.setU(p.getU());} else {s.setU(0);}s.setU_IN(p.getU_IN());s.setU_OUT(p.getU_OUT());set_series(s);}}}else {double ju=S.getU_IN();for(total to:S.getTo()){to.setII(S.getI());to.setII(S.getI());to.setU_IN(ju);ju=ju-to.getUU();to.setU_OUT(ju);if(to instanceof controlled){controlled c=(controlled) to;if(c instanceof H){H h=(H)c;if(h.getWay()==1){h.setU_1(h.getU_IN());if(h.getState()==2){h.setU_2(h.getU_OUT());}else {h.setU_3(h.getU_OUT());}}else {h.setU_1(h.getU_OUT());if(h.getState()==2){h.setU_2(h.getU_IN());}else {h.setU_3(h.getU_IN());}}}}}for(Series s: S.getSer()){s.setU(S.getI()*s.getR());set_series(s);}for (controlled c : S.getCtrd()) {c.setI(S.getI());}for (Parallel p : S.getPar()) {p.setI(S.getI());for (Series s : p.getSer()) {s.setU_IN(p.getU_IN());s.setU_OUT(p.getU_OUT());if (s.getState() == 1) {s.setU(p.getU());} else {s.setU(0);}set_series(s);}}}}totol类 ：class total{private double II;private double U_IN;private double U_OUT;public double getRR() {if(this instanceof controlled){controlled c=(controlled) this;return c.getR();}else if(this instanceof Series){Series s=(Series) this;return s.getR();} else if (this instanceof Parallel) {Parallel p=(Parallel) this;return p.getR();}return 0;}public double getII() {return II;}public void setII(double II) {this.II = II;}public double getUU() {if(this instanceof controll){controll c=(controll) this;if(c instanceof K){K k=(K)c;return k.getU();}else if(c instanceof L){L l=(L)c;return l.getU();}else if(c instanceof F){F f=(F)c;return f.getU();}}else {return getII()*getRR();}return 0;}public double getU_IN() {return U_IN;}public void setU_IN(double u_IN) {U_IN = u_IN;}public double getU_OUT() {return U_OUT;}public void setU_OUT(double u_OUT) {U_OUT = u_OUT;}
}

本次作业的错误分析

互斥开关有两种呈现方式，并且只能出现在并联电路中的小串联电路中，不会出现主电路中。一种方式是H-1在输入电压这端，另一种方式是H-1在输出电压那端，我在互斥开关中增添一个内部变量way，以此来判断他呈现的方式（以下展示互斥开关类）

点击查看代码

class H extends controlled implements Comparable<H>{private int state=2;//2、3private int way=0;private double U_1;private double U_2;private double U_3;public int getWay() {return way;}public void setWay(int way) {this.way = way;}public double getU_1() {return U_1;}public void setU_1(double u_1) {U_1 = u_1;}public double getU_2() {return U_2;}public void setU_2(double u_2) {U_2 = u_2;}public double getU_3() {return U_3;}public void setU_3(double u_3) {U_3 = u_3;}@Overridepublic String getstata() {if(state==2){return "closed";}else {return  "turned on";}}public void changestate(){if(state==2){state=3;}elsestate=2;}public H(){}public int getState(){return state;}@Overridepublic int compareTo(H o) {return Integer.compare(this.getNumber(), o.getNumber());}
}

对于输出的格式要求，可以先用System.out.print来输出原始数据，等输出完一个之后，用System.out.println来换行（以下展示示例代码）

点击查看代码

for(H h :H_list){System.out.print("@" + h.getName() + ":" + h.getstata() + " " + (int)h.getU_1() + "-" + (int)h.getU_2() + "-" + (int)h.getU_3() );if(h.getI()>20){System.out.print(" exceeding current limit error");}System.out.println();}