关于nchu三次题目集7-1题目的总结
关于nchu三次题目集7-1题目的总结
一、前言
关于这三次的题目集，题目为家具强电器电路模拟程序，前提是在如今只能家具越来越流行的情况下，使用模拟程序控制智能家居强电器电路就很有必要，此次题目是考究的是我们对复杂问题的分析与处理能力，需要将串联电路以及并联电路模拟，深刻理解并通过代码实现，我们需要仔细分析题目需求，此次难点主要在题目信息的理解和电器及电路的模拟上。
二、内容
第三次题目（简略版）
1、控制设备
本题模拟的控制设备包括：开关、分档调速器、连续调速器、互斥开关。
开关：包括0和1两种状态。
互斥开关：互斥开关有3个引脚：1个是汇总引脚，另两个是分支引脚。互斥开关只有两种状态：开关接往上面的2号引脚、接往下面的3号引脚。开关每次只能接通其中一个分支引脚，而另一个分支引脚处于断开状态。互斥开关的默认状态为1、2引脚接通，1、3引脚断开。
为避免短路，互斥开关设置了限流电阻，12引脚之间默认电阻为5，13引脚之间默认电阻为10。
分档调速器：按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。
开关、调速器的初始状态/档位为0。
开关、调速器的输入引脚编号为1，输出引脚编号为2。
除互斥开关外，其他控制设备的电阻为 0。2、受控设备
本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。
本次迭代模拟两种灯具。
白炽灯；
日光灯；
本次迭代模拟两种风扇。
吊扇；
落地扇；
本次迭代模拟一种受控窗帘：
受控串联的电路符号为S，其最低工作电压为50V，电压达到或超过50V，窗帘即可正常工作，不考虑室外光照强度和室内空间大小等因素，窗帘受室内灯光的光照强度控制。
受控设备电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落地扇的电阻为 20，窗帘电阻为15。
3、输入信息
1）输入设备信息
分别用设备标识符K、F、L、B、R、D、A、H、S分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇、互斥开关、受控窗帘。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。
约束条件：不同设备的编号可以相同。
同种设备的编号可以不连续。设备信息不单独输入，包含在连接信息中。
2）输入连接信息
一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。
约束条件：不考虑调速器串联到其他调速器的情况。
不考虑调速器串联到其他调速器的情况。考虑各类设备的并联接入。例如，K1 的输出接到 L2 的输入，L2 的输出再接其他设备属于串联接线。K1 的输出接到 L2 的输出，同时 K1 的输入接到 L2 的输入，这种情况属于并联。
本次迭代的连接信息不单独输入，包含在线路信息中。
3）输入控制设备调节信息
开关、互斥开关调节信息格式：
分档调速器的调节信息格式：
连续调速器的调节信息格式：
4）电源接地标识：
VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。
5）输入串联电路信息
一条串联电路占一行，串联电路由按从靠电源端到接地端顺序依次输入的 n 个连接 信息组成，连接信息之间用英文空格" "分隔。
约束条件：不同的串联电路信息编号不同。
输入的最后一条电路信息必定是总电路信息，总电路信息的起始引脚是 VCC，结束引脚是 GND。
6）输入并联电路信息
一条并联电路占一行，并联电路由其包含的几条串联电路组成，串联电路标识之间用英文空格" "分隔。
格式：
约束条件：本次迭代不考虑并联电路中包含并联电路的情况。
本题不考虑输入电压或电压差超过220V的情况。
输入信息以end为结束标志，忽略end之后的输入信息。
本题中的并联信息所包含的串联电路的信息都在并联信息之前输入，不考虑乱序输入的情况。
只要不因短路而造成无穷大的电流烧坏电路(如电路中的部分短接)，都是合理情况，在测试点的考虑范围之内。会造成无穷大的电流的短路本次迭代不考虑。本次迭代考虑多个并联电路串联在一起的情况。
**本题考虑一条串联电路中包含其他串联电路的情况。
4、输出信息：
按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、互斥开关、受控窗帘的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。
互斥开关显示1、2引脚的接通状态，接通时显示closed，断开时显示turned on。
5、家居电路模拟系列所有题目的默认规则：**
1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。
2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。
3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。
4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。
6、家居电路模拟系列1-4题目后续迭代设计：
1）电路结构变化：
迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系2）计算方式的变化
迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。
3）电路元件的变化
每次迭代会增加1-2个新的电路元件。
图1：电路结构示意图
设计建议：
1、电路设备类：描述所有电路设备的公共特征。
2、受控设备类、控制设备类：对应受控、控制设备
3、串联电路类：一条由多个电路设备构成的串联电路，也看成是一个独立的电路设备
4、并联电路类：继承电路设备类，也看成是一个独立的电路设备
其他类以及类的属性、方法自行设计。
我的代码
import java.util.Scanner;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Map;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
Map<String,CircuitEquipment> elements=new TreeMap<String, CircuitEquipment>();//存储所有电路设备，方便最后输出
Map<String, SeriesCircuit> series=new TreeMap<String, SeriesCircuit>();//存储所有电路，但不包括并联电路
Map<String, ParallelCircuit> parallels=new TreeMap<String, ParallelCircuit>();//存储所有并联电路
SeriesCircuit mainSerie=new SeriesCircuit();
String strMatches1="#(\\w+):(\\[(IN|\\w+-\\d) (OUT|\\w+-\\d)\\]\\s*)+";//串联电路
String strMatches2="#(\\w+):\\[(\\s*?T\\d)+\\]";//并联电路
String strMatches3="#(\\w+):(\\[(VCC|\\w+-\\w+) (GND|\\w+-\\w+)\\]\\s*)+";//主电路
String strMAtches5="#(\\w\\d):*([\\S]*)";//控制设备操作
String strreg="(OUT|GND|VCC|IN|\\w\\d-(\\w+))";//普通设备连接信息
String strregParallel="(M|T)(\\d)";//并联电路信息
String str=in.nextLine();
while(!str.equals("end")) {
Pattern pattern=Pattern.compile(strreg);
Matcher matcher=pattern.matcher(str);
Pattern patternParallel=Pattern.compile(strregParallel);
Matcher matcherParallel=patternParallel.matcher(str);
if(Pattern.matches(strMatches1, str)) {
SeriesCircuit newOne=new SeriesCircuit();
if(matcherParallel.find()) {
while(matcher.find()) {
String name=String.valueOf(matcher.group().charAt(0))+String.valueOf(matcher.group().charAt(1));
String group2result=matcher.group(2);
if(group2result!=null) {
if(!elements.containsKey(name)&&matcher.group(2).equals("1")) {
switch(matcher.group().charAt(0)) {
case 'K':
OnOff k=new OnOff();
k.setName(name);
newOne.addItem(k);
elements.put(k.getName(), k);
break;
case 'F':
SpeedController f=new SpeedController();
f.setName(name);
newOne.addItem(f);
elements.put(f.getName(), f);
break;
case 'L':
VariableSpeedController l=new VariableSpeedController();
l.setName(name);
newOne.addItem(l);
elements.put(l.getName(), l);
break;
case 'B':
IncandescentLightBulb b=new IncandescentLightBulb();
b.setName(name);
newOne.addItem(b);
elements.put(b.getName(), b);
break;
case 'R':
FluorescentLightBulb r=new FluorescentLightBulb();
r.setName(name);
newOne.addItem(r);
elements.put(r.getName(), r);
break;
case 'D':
CeilingFan d=new CeilingFan();
d.setName(name);
newOne.addItem(d);
elements.put(d.getName(), d);
break;
case 'A':
FloorFan a=new FloorFan();
a.setName(name);
newOne.addItem(a);
elements.put(a.getName(), a);
break;
}
}else if(elements.containsKey(name)){
if(!newOne.extists(name)) {
newOne.addItem(elements.get(name));
}
}
}
}
series.put(matcherParallel.group(), newOne);
}
}else if(Pattern.matches(strMatches2, str)) {
if(matcherParallel.find()) {
ParallelCircuit newOne=new ParallelCircuit();
String name=matcherParallel.group();
newOne.setName(name);
while(matcherParallel.find()) {
newOne.addSerieids(matcherParallel.group());
}
parallels.put(name, newOne);
}
}else if(Pattern.matches(strMatches3, str)) {
if(matcherParallel.find()) {
SeriesCircuit newOne=new SeriesCircuit();
while(matcher.find()) {
if(matcher.group().equals("VCC")) {
CircuitEquipment vcc=new CircuitEquipment();
vcc.setName("VCC");
vcc.setPin2Volt(220);
newOne.addItem(vcc);
}else {
String name=String.valueOf(matcher.group().charAt(0))+String.valueOf(matcher.group().charAt(1));
if(name.contains("M")&&matcher.group().contains("IN")) {
if(parallels.containsKey(name))
newOne.addItem(parallels.get(name));
}
if(!elements.containsKey(name)) {
switch(matcher.group().charAt(0)) {
case 'K':
OnOff k=new OnOff();
k.setName(name);
newOne.addItem(k);
elements.put(k.getName(), k);
break;
case 'F':
SpeedController f=new SpeedController();
f.setName(name);
newOne.addItem(f);
elements.put(f.getName(), f);
break;
case 'L':
VariableSpeedController l=new VariableSpeedController();
l.setName(name);
newOne.addItem(l);
elements.put(l.getName(), l);
break;
case 'B':
IncandescentLightBulb b=new IncandescentLightBulb();
b.setName(name);
newOne.addItem(b);
elements.put(b.getName(), b);
break;
case 'R':
FluorescentLightBulb r=new FluorescentLightBulb();
r.setName(name);
newOne.addItem(r);
elements.put(r.getName(), r);
break;
case 'D':
CeilingFan d=new CeilingFan();
d.setName(name);
newOne.addItem(d);
elements.put(d.getName(), d);
break;
case 'A':
FloorFan a=new FloorFan();
a.setName(name);
newOne.addItem(a);
elements.put(a.getName(), a);
break;
}
}else {
if(!newOne.extists(name)) {
newOne.addItem(elements.get(name));
}
}
}
mainSerie=newOne;
series.put(matcherParallel.group(), newOne);
}
}
}else if(Pattern.matches(strMAtches5, str)) {
Pattern pa5=Pattern.compile(strMAtches5);
Matcher mp5=pa5.matcher(str);
if(mp5.find()) {
String name=mp5.group(1);
String operation=mp5.group(2);
switch(name.charAt(0)) {
case 'K':
OnOff k=(OnOff)elements.get(name);
k.switchState();
break;
case 'F':
SpeedController f=(SpeedController)elements.get(name);
if(operation.equals("+"))
f.UpShift();
else f.DownShift();
break;
case 'L':
VariableSpeedController l=(VariableSpeedController)elements.get(name);
l.setGear(Double.valueOf(operation));
break;
}
}
}
str=in.nextLine();
}
for(String key:parallels.keySet()) {
ParallelCircuit par=(ParallelCircuit)mainSerie.getCircuitEquipment(key);
for(int i=0;i<par.getSeriesid().size();i++) {
par.addSeries(series.get(par.getSeriesid().get(i)));
}
}
ArrayList<CircuitEquipment> item=mainSerie.getItem();
if(mainSerie.isClosed()==0) {
for(int i=0;i<item.size();i++) {
if(i==0) {
item.get(i).setPin2(item.get(i+1).getName());
item.get(i+1).setPin1("VCC");
item.get(i+1).setPin1Volt(220);
}else if(i<item.size()-1) {
if(item.get(i).getName().contains("K")) {
item.get(i).setPin2Volt(item.get(i).getPin1Volt());
item.get(i).setPin2(item.get(i+1).getName());
item.get(i+1).setPin1(item.get(i).getName());
item.get(i+1).setPin1Volt(item.get(i).getPin2Volt());
}else if(item.get(i).getName().contains("L")) {
VariableSpeedController l=(VariableSpeedController)item.get(i);
l.setPin2Volt(l.getGear()*l.getPin1Volt());
l.setPin2(item.get(i+1).getName());
item.get(i+1).setPin1(l.getName());
item.get(i+1).setPin1Volt(l.getPin2Volt());
}else if(item.get(i).getName().contains("F")) {
SpeedController f=(SpeedController)item.get(i);
f.setPin2Volt(f.getDGear()*f.getPin1Volt());
f.setPin2(item.get(i+1).getName());
item.get(i+1).setPin1(f.getName());
item.get(i+1).setPin1Volt(f.getPin2Volt());
}
//****************************************************
else if(item.get(i).getName().contains("M")) {
ParallelCircuit m=(ParallelCircuit)item.get(i);
m.compulateResis();
double voltage=m.getPin1Volt()*(m.getResistance()/mainSerie.getAfterResis(i));
m.setPin2(item.get(i+1).getName());
m.setPin2Volt(m.getPin1Volt()-voltage);
item.get(i+1).setPin1(item.get(i).getName());
item.get(i+1).setPin1Volt(item.get(i).getPin2Volt());
//并联内部操作
for(int j=0;j<m.getSeries().size();j++) {
ArrayList<CircuitEquipment> item2=m.getSeries().get(j).getItem();
if(m.getSeries().get(j).isClosed()==0) {
for(int k=0;k<item2.size();k++) {
if(k==0) {
item2.get(k).setPin1(item.get(i-1).getName());
item2.get(k).setPin1Volt(m.getPin1Volt());
item2.get(k).setPin2Volt(item2.get(k).getPin1Volt());
double voltage2=m.getVlotageDifference()*(item2.get(k).getResistance()/m.getSeries().get(j).getAfterResis(k));
item2.get(k).setPin2(item2.get(k+1).getName());
item2.get(k).setPin2Volt(voltage2);
item2.get(k+1).setPin1(item2.get(k).getName());
item2.get(k+1).setPin1Volt(item2.get(k).getPin2Volt());
if(item2.get(k).getName().contains("K")) {
item2.get(k).setPin1(item.get(i-1).getName());
item2.get(k).setPin1Volt(m.getPin1Volt());
item2.get(k).setPin2Volt(item2.get(k).getPin1Volt());
item2.get(k).setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(item2.get(k).getName());
item2.get(k+1).setPin1Volt(item2.get(k).getPin2Volt());
}else if(item2.get(k).getName().contains("L")) {
item2.get(k).setPin1(item.get(i-1).getName());
item2.get(k).setPin1Volt(m.getPin1Volt());
VariableSpeedController l=(VariableSpeedController)item2.get(k);
l.setPin2Volt(l.getGear()*l.getPin1Volt());
l.setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(l.getName());
item2.get(k+1).setPin1Volt(l.getPin2Volt());
}else if(item2.get(k).getName().contains("F")) {
item2.get(k).setPin1(item.get(i-1).getName());
item2.get(k).setPin1Volt(m.getPin1Volt());
SpeedController f=(SpeedController)item2.get(k);
f.setPin2Volt(f.getDGear()*f.getPin1Volt());
f.setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(f.getName());
item2.get(k+1).setPin1Volt(f.getPin2Volt());
}else {
item2.get(k).setPin1(item.get(i-1).getName());
item2.get(k).setPin1Volt(m.getPin1Volt());
double voltage3=item2.get(k).getPin1Volt()*(item2.get(k).getResistance()/m.getSeries().get(j).getAfterResis(k));
item2.get(k).setPin2Volt(voltage3);
item2.get(k).setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(item2.get(k).getName());
item2.get(k+1).setPin1Volt(item2.get(k).getPin2Volt());
}
}else if(k<item2.size()-1) {
if(item2.get(k).getName().contains("K")) {
item2.get(k).setPin2Volt(item2.get(k).getPin1Volt());
item2.get(k).setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(item2.get(k).getName());
item2.get(k+1).setPin1Volt(item2.get(k).getPin2Volt());
}else if(item2.get(k).getName().contains("L")) {
VariableSpeedController l=(VariableSpeedController)item2.get(k);
l.setPin2Volt(l.getGear()*l.getPin1Volt());
l.setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(l.getName());
item2.get(k+1).setPin1Volt(l.getPin2Volt());
}else if(item2.get(k).getName().contains("F")) {
SpeedController f=(SpeedController)item2.get(k);
f.setPin2Volt(f.getDGear()*f.getPin1Volt());
f.setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(f.getName());
item2.get(k+1).setPin1Volt(f.getPin2Volt());
}else {
double voltage2=item2.get(k).getPin1Volt()*(item2.get(k).getResistance()/m.getSeries().get(j).getAfterResis(k));
item2.get(k).setPin2Volt(voltage2);
item2.get(k).setPin2(item2.get(k+1).getName());
item2.get(k+1).setPin1(item2.get(k).getName());
item2.get(k+1).setPin1Volt(item2.get(k).getPin2Volt());
}
}else if(k==item2.size()-1) {
item2.get(k).setPin2Volt(m.getPin2Volt());
item2.get(k).setPin2(item.get(i+1).getName());
}
}
}
}
//*******************************************
}else {
double voltage=item.get(i).getPin1Volt()*(item.get(i).getResistance()/mainSerie.getAfterResis(i));
item.get(i).setPin2Volt(voltage);
item.get(i).setPin2(item.get(i+1).getName());
item.get(i+1).setPin1(item.get(i).getName());
item.get(i+1).setPin1Volt(item.get(i).getPin2Volt());
}
}else if(i==item.size()-1) {
item.get(i).setPin2Volt(0);
item.get(i).setPin2("GND");
}
}
}
in.close();
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("K")) {
OnOff k=(OnOff)elements.get(key);
if(k.getState()==0)
System.out.println("@"+k.getName()+":turned on");
else System.out.println("@"+k.getName()+":closed");
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("F")) {
SpeedController f=(SpeedController)elements.get(key);
System.out.println("@"+f.getName()+":"+f.getGear());
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("L")) {
VariableSpeedController l=(VariableSpeedController)elements.get(key);
System.out.printf("@%s:%.2f\n",l.getName(),l.getGear());
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("B")) {
IncandescentLightBulb b=(IncandescentLightBulb)elements.get(key);
System.out.println("@"+b.getName()+":"+b.getLuminance());
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("R")) {
FluorescentLightBulb r=(FluorescentLightBulb)elements.get(key);
System.out.println("@"+r.getName()+":"+r.getLuminance());
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("D")) {
CeilingFan d=(CeilingFan)elements.get(key);
System.out.println("@"+d.getName()+":"+d.getRotationRate());
}
}
for(String key:elements.keySet()) {
if(elements.get(key).getName().contains("A")) {
FloorFan a=(FloorFan)elements.get(key);
System.out.println("@"+a.getName()+":"+a.getRotationRate());
}
}
}
}
class CircuitEquipment {
private String name;//设备名
private String pin1;//接入引脚
private String pin2;//输出引脚
private double pin1Volt;//输入电压
private double pin2Volt;//输出电压
private double resistance;//电阻值
public CircuitEquipment(String name, String pin1, String pin2, double pin1Volt, double pin2Volt,
double resistance) {
super();
this.name = name;
this.pin1 = pin1;
this.pin2 = pin2;
this.pin1Volt = pin1Volt;
this.pin2Volt = pin2Volt;
this.resistance = resistance;
}
public CircuitEquipment() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPin1() {
return pin1;
}
public void setPin1(String pin1) {
this.pin1 = pin1;
}
public String getPin2() {
return pin2;
}
public void setPin2(String pin2) {
this.pin2 = pin2;
}
public void setPin1Volt(double pin1Volt) {
this.pin1Volt = pin1Volt;
if(pin1Volt==0)
this.setPin2Volt(0);
}
public void setPin2Volt(double pin2Volt) {
this.pin2Volt = pin2Volt;
}
public double getPin1Volt() {
return pin1Volt;
}
public double getPin2Volt() {
return pin2Volt;
}
public double getResistance() {
return resistance;
}
public void setResistance(double resistance) {
this.resistance = resistance;
}
public double getVlotageDifference() {
return Double.valueOf(String.format("%.2f", pin1Volt-pin2Volt));
}
}
class CeilingFan extends CircuitEquipment{
public CeilingFan() {
super();
setResistance(20);
}
public int getRotationRate() {
double V=getVlotageDifference();
if(V<80)
return 0;
else if(V<150)
return (int)(4*V-240);
else
return 360;
}
}
class FloorFan extends CircuitEquipment{
public FloorFan() {
super();
setResistance(20);
}
public int getRotationRate() {
double V=getVlotageDifference();
if(V<80)
return 0;
else if(V<100)
return 80;
else if(V<120)
return 160;
else if(V<140)
return 260;
else return 360;
}
}
class FluorescentLightBulb extends CircuitEquipment{
public FluorescentLightBulb() {
super();
setResistance(5);
}
public int getLuminance() {
if(getVlotageDifference()==0)
return 0;
return 180;
}
}
class IncandescentLightBulb extends CircuitEquipment{
public int getLuminance(){
if(getVlotageDifference()<10)
return 0;
return(int) (50+(getVlotageDifference()-10)*5/7);
}
public IncandescentLightBulb() {
super();
setResistance(10);
}
}
class OnOff extends CircuitEquipment{
private final int On=1;
private final int Off=0;
private int state;
public OnOff() {
super();
}
public int getState() {
return state;
}
//设置引脚电压
@Override
public void setPin1Volt(double pin1Volt) {
super.setPin1Volt(pin1Volt);
if(state==On) setPin2Volt(pin1Volt);
}
//改变开关状态（开变关或关变开）
public void switchState() {
if(state==On)
state=Off;
else state=On;
}
}
class ParallelCircuit extends CircuitEquipment{
private ArrayList<String> serieids=new ArrayList<String>();
private ArrayList<SeriesCircuit> series=new ArrayList<SeriesCircuit>();
public ParallelCircuit() {
super();
}
public void addSeries(SeriesCircuit o) {
series.add(o);
double product=1;
double sum=0;
for(int i=0;i<series.size();i++) {
product*=series.get(i).getResistance();
sum+=series.get(i).getResistance();
}
setResistance(product/sum);
}
public int isClosed() {
for(int i=0;i<series.size();i++) {
if(series.get(i).isClosed()==0)
return 0;
}
return 1;
}
public void compulateResis() {
int n=series.size();
double product=1;
double sum=0;
for(int i=0;i<series.size();i++) {
if(series.get(i).isClosed()==0) {
product*=series.get(i).getResistance();
sum+=series.get(i).getResistance();
}else {
n--;
}
}
if(n==1){
setResistance(sum);
}else {
setResistance(product/sum);
}
}
public ArrayList<SeriesCircuit> getSeries(){
return series;
}
public ArrayList<String> getSeriesid(){
return serieids;
}
public void addSerieids(String name) {
serieids.add(name);
}
}
class SeriesCircuit {
private double resistance;
private ArrayList<CircuitEquipment> item=new ArrayList<>();
public SeriesCircuit() {
super();
}
public void addItem(CircuitEquipment element) {
item.add(element);
}
public ArrayList<CircuitEquipment> getItem() {
return item;
}
public void setResistance(double resistance) {
this.resistance = resistance;
}
public double getResistance() {
double r=0;
for(int i=0;i<item.size();i++)
r+=item.get(i).getResistance();
resistance=r;
return resistance;
}
//检测是否存在该电器
public Boolean extists(String name) {
for(int i=0;i<item.size();i++)
if(item.get(i).getName().equals(name))
return true;
return false;
}
//通过名字寻找电器
public CircuitEquipment getCircuitEquipment(String name) {
int index=0;
for(int i=0;i<item.size();i++)
if(item.get(i).getName().equals(name))
index=i;
return item.get(index);
}
//寻找下一位，若不存在则返回自己
public CircuitEquipment next(String name) {
int index=0;
for(int i=0;i<item.size();i++)
if(item.get(i).getName().equals(name))
index=i;
if(index<item.size()-1)
return item.get(index+1);
else return item.get(index);
}
//寻找前一位，若不存在则返回自己
public CircuitEquipment before(String name) {
int index=0;
for(int i=0;i<item.size();i++)
if(item.get(i).getName().equals(name))
index=i;
if(index-1>=0)
return item.get(index-1);
else return item.get(index);
}
//寻找最后一位
public CircuitEquipment last() {
return item.get(item.size());
}
//判断电路是否闭合
public int isClosed() {
int flag=0;
for(int i=0;i<item.size();i++) {
if(item.get(i).getName().charAt(0)=='K') {
OnOff k=(OnOff)item.get(i);
if(k.getState()==0)
flag++;
}
if(item.get(i).getName().charAt(0)=='M') {
ParallelCircuit p=(ParallelCircuit)item.get(i);
if(p.isClosed()!=0)
flag++;
}
}
return flag;
}
//获得一个电器及后面所有电器的总电压
public double getAfterResis(int index)
{
double ar=0;
for(int i=index;i<item.size();i++)
{
ar+=item.get(i).getResistance();
}
return ar;
}
//展示电路信息
public void show() {
for(int i=0;i<item.size();i++) {
switch(item.get(i).getName().charAt(0)) {
case 'K':
OnOff k=(OnOff)item.get(i);
if(k.getState()==0)
System.out.println("@"+k.getName()+":turned on");
else System.out.println("@"+k.getName()+":closed");
break;
case 'F':
SpeedController f=(SpeedController)item.get(i);
System.out.println("@"+f.getName()+":"+f.getGear());
break;
case 'L':
VariableSpeedController l=(VariableSpeedController)item.get(i);
System.out.printf("@%s:%.2f\n",l.getName(),l.getGear());
break;
case 'B':
IncandescentLightBulb b=(IncandescentLightBulb)item.get(i);
System.out.println("@"+b.getName()+":"+b.getLuminance());
break;
case 'R':
FluorescentLightBulb r=(FluorescentLightBulb)item.get(i);
System.out.println("@"+r.getName()+":"+r.getLuminance());
break;
case 'D':
CeilingFan d=(CeilingFan)item.get(i);
System.out.println("@"+d.getName()+":"+d.getRotationRate());
break;
}
}
}
}
class SpeedController extends CircuitEquipment{
private final double First=0;
private final double Second=0.3;
private final double Third=0.6;
private final double Four=0.9;
private double Gear;
public SpeedController() {
super();
}
public Double getDGear() {
return Gear;
}
public int getGear() {
if(Gear==Third)
return 2;
if(Gear==Second)
return 1;
if(Gear==Four)
return 3;
return 0;
}
public void UpShift() {
if(Gear==Third)
Gear=Four;
if(Gear==Second)
Gear=Third;
if(Gear==First)
Gear=Second;
setPin2Volt(Gear*getPin1Volt());
}
public void DownShift() {
if(Gear==Second)
Gear=First;
if(Gear==Third)
Gear=Second;
if(Gear==Four)
Gear=Third;
setPin2Volt(Gear*getPin1Volt());
}
}
class VariableSpeedController extends CircuitEquipment{
private double Gear;
public VariableSpeedController() {
super();
}
public double getGear() {
return Gear;
}
public void setGear(double gear) {
if(Gear>=0&&Gear<=1)
Gear = gear;
setPin2Volt(Gear*getPin1Volt());
}
}
设计与分析
根据题目需求，我设计了十个基本类用于储存、修改和输出电路中个电器信息。
电器类（CircuitsEquipment）
这是其他电器的父类，电器类，子类有如开关、变阻器、灯、扇，等等。
开关类（OnOff，为与“switch”做区分）
继承父类电器类。
连续调速器类（VariableSpeedController）
分档调速器类（SpeedController）
串联电路类（SeriesCircuit）
并联电路类（ParallelCircuit）
含有串联类并继承电路类。
白炽灯类（IncandescentLightBulb）
日光灯类（FluorescentLightBulb）
落地扇类（FloorFan）
吊扇类（CeilingFan）
上四类皆继承自电器类，并含有自身的特殊属性。
踩坑心得
在使用Java编写家具强电器电路模拟程序的过程中，我遇到了一些预料之外的挑战和“坑”，这些经历让我深刻体会到了编程的复杂性和细致性。
首先，我遇到的第一个“坑”是电路逻辑的复杂性。在家具强电器电路中，往往涉及到多个电器设备的并联和串联，以及开关的通断控制。在初始设计时，我过于简化了电路模型，没有充分考虑到各种可能的电路状态和边界情况，导致程序在实际运行中出现了不少问题。为了解决这些问题，我不得不重新梳理电路逻辑，对代码进行了大量的修改和调试。
其次，我在处理异常和错误时遇到了困难。在模拟电路的过程中，可能会遇到各种异常情况，如电路短路、过载等。最初，我没有为这些情况设计充分的异常处理机制，导致程序在遇到问题时无法给出明确的提示或进行适当的处理。为了解决这一问题，我花费了不少时间学习和理解Java的异常处理机制，并在程序中添加了相应的异常处理代码。
另外，我在内存管理方面也遇到了一些挑战。在模拟电路的过程中，需要频繁地创建和销毁电路对象。最初，我没有注意到内存泄漏的问题，导致程序在长时间运行后出现了性能下降的现象。通过深入学习Java的内存管理机制和垃圾回收机制，我发现了内存泄漏的根源，并优化了代码以减少不必要的对象创建。
改进建议
- 增强电路逻辑模型：
首先，我们需要对电路逻辑模型进行更深入的研究和设计。确保模型能够准确模拟各种复杂的电路结构，包括并联、串联以及开关的通断状态。此外，还应该考虑电路中的异常情况，如短路、过载等，并设计相应的处理机制。 - 优化异常处理机制：
在现有的程序中，异常处理可能还不够完善。建议添加更详细的异常分类，并为每种异常提供明确的错误提示和建议的解决方案。这样，当电路出现问题时，用户能够更快地定位问题并进行修复。 - 提高内存管理效率：
对于频繁创建和销毁电路对象的情况，我们可以考虑使用对象池技术来减少内存分配和垃圾回收的开销。此外，对于不再使用的对象，应及时进行清理，避免内存泄漏。
三、总结
在完成家具强电器电路模拟程序的作业过程中，我深入了解了电路模拟的基本原理，并借助Java编程语言将这些原理付诸实践。这个过程不仅锻炼了我的编程能力，也加深了我对电路知识的理解。以下是我对这次作业的总结。在开始编程之前，我首先对电路模拟的概念和目的进行了研究，明确了需要模拟的电路类型、功能需求以及性能要求。我查阅了相关的电路知识和Java编程资料，为后续的编程工作打下了坚实的基础。在测试过程中，我发现了一些潜在的bug和性能问题，并及时进行了修复和优化。通过这次作业，我深刻体会到了编程的魅力和挑战。我不仅学会了如何使用Java编程语言实现电路模拟的功能，还锻炼了自己的逻辑思维和问题解决能力。同时，我也认识到了自己在编程和电路知识方面的不足，需要进一步加强学习和实践。在未来的学习和工作中，我将继续深入学习Java编程和电路知识，不断提高自己的编程能力和专业素养。同时，我也将注重实践经验的积累，积极参与项目实践和创新实践活动，提升自己的综合素质和能力。总之，这次作业是一次非常有意义的学习经历。通过完成家具强电器电路模拟程序的任务，我不仅掌握了相关的知识和技能，还收获了宝贵的经验和教训。我将继续努力学习和实践，为自己的未来发展打下坚实的基础。
“日新自强，知行合一”。
浙公网安备 33010602011771号