關於nchu三次題目集7-1題目的總結
一、前言
關於這三次的題目集，題目為傢俱強電器電路模擬程式，前提是在如今只能傢俱越來越流行的情況下，使用模擬程式控制智慧家居強電器電路就很有必要，此次題目是考究的是我們對複雜問題的分析與處理能力，需要將串聯電路以及並聯電路模擬，深刻理解並透過程式碼實現，我們需要仔細分析題目需求，此次難點主要在題目資訊的理解和電器及電路的模擬上。
二、內容
- [題目[1]](##第三次題目（簡略版）)
- [程式碼[2]](##我的程式碼)
- [設計與分析[3]](##設計與分析)
- [踩坑心得[4]](##踩坑心得)
- [改進建議[5]](##改進建議)
第三次題目（簡略版）
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程式設計和電路知識，不斷提高自己的程式設計能力和專業素養。同時，我也將注重實踐經驗的積累，積極參與專案實踐和創新實踐活動，提升自己的綜合素質和能力。總之，這次作業是一次非常有意義的學習經歷。透過完成傢俱強電器電路模擬程式的任務，我不僅掌握了相關的知識和技能，還收穫了寶貴的經驗和教訓。我將繼續努力學習和實踐，為自己的未來發展打下堅實的基礎。
“日新自強，知行合一”。
題目 ↩︎
程式碼 ↩︎
設計與分析 ↩︎
踩坑心得 ↩︎
改進建議 ↩︎