第二阶段三次PTA作业总结
一、前言
PTA作业已经进入第二阶段，第二阶段与第一阶段的题目有所不同，主要为电路模拟程序
这三次的PTA作业第一次为“答题判题程序-4” ，他是以前三次答题判题程序为基础所扩展的；第二次作业为全新的题型“家居强电电路模拟程序-1”，主要内容为设计一个智能家居强电电路模拟系统；第三次作业是以“家居强电电路模拟程序-1”为基础迭代的“家居强电电路模拟程序-2”，它在1的基础上增加了并联电路，修改了输入格式等等。虽然难度上总体小于答题判题程序，但还是有挑战性的。
二、设计与分析
接下来，我将会对这三次的作业进行分析。
点击查看代码
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
}
}
abstract class DealStr {
protected String line;
public DealStr() {
}
public DealStr(String line) {
this.line = line;
}
}
class StrWithN extends DealStr{
public StrWithN() {
super();
}
public N_Question dealStr() {
N_Question question = new N_Question();
//QuestionPaper qusetionpaper = new QuestionPaper();
String[] input = line.split("#N:| #Q:| #A:");
String num = input[1].trim();
String content = input[2].trim();
String answer = input[3].trim();
question.setNum(num);
question.setContent(content);
question.setAnswer(answer);
//qusetionpaper.setQuestion_n(num, question);
return question;
}
}
class StrWithK extends DealStr {
}
class StrWithZ extends DealStr {
}
class StrWithX extends DealStr {
}
class StrWithT extends DealStr {
}
class StrWithS extends DealStr {
}
class QuestionPaper {
HashMap<String, N_Question> question_n = new HashMap();
HashMap<String, K_Question> question_k = new HashMap();
HashMap<String, Z_Question> question_z = new HashMap();
public HashMap<String, N_Question> getQuestion_n() {
return question_n;
}
/*public void setQuestion_n(HashMap<String, N_Question> question_n) {
this.question_n = question_n;
}*/
public void setQuestion_n(String num, N_Question question_n) {
this.question_n.put(num, question_n);
}
public HashMap<String, K_Question> getQuestion_k() {
return question_k;
}
/*public void setQuestion_k(HashMap<String, K_Question> question_k) {
this.question_k = question_k;
}*/
public void setQuestion_k(String num, K_Question question_k) {
this.question_k.put(num, question_k);
}
public HashMap<String, Z_Question> getQuestion_z() {
return question_z;
}
/*public void setQuestion_z(HashMap<String, Z_Question> question_z) {
this.question_z = question_z;
}*/
public void setQuestion_z(String num, Z_Question question_z) {
this.question_z.put(num, question_z);
}
}
abstract class Question {
protected String num;
protected String content;
//protected String answer;
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
class N_Question extends Question {
protected String answer;
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Z_Question extends Question {
protected String[] answer;
public String[] getAnswer() {
return answer;
}
public void setAnswer(String[] answer) {
this.answer = answer;
}
}
class K_Question extends Question {
protected String[] answer;
public String[] getAnswer() {
return answer;
}
public void setAnswer(String[] answer) {
this.answer = answer;
}
}
class TextPaper {
}
class AnswerSheet {
}
class StudentInfo {
}
class DeleteQuestion {
}
1、答题判题程序-4
以下是代码的类图
“答题判题程序-4”在“答题判题程序-3”的基础上新增内容为输入选择题题目信息、输入填空题题目信息、输出顺序变化以及多张试卷信息
这次的代码我并未写出来，没能得分，只设计了类结构图，上述代码也是不完整的代码，因为能力有限，再加上其他科目的作业需求，导致没能完成代码。
因为前三次我的代码并没有可扩展性和可维护性，所以我重新设计了类结构图。我将字符串处理类DealStr抽象，并定义了多个子类继承字符串处理类DealStr来处理不同的输入，为的是应对下次迭代时需要增加或修改输入方式。同样，我将问题类Question也抽象化，并定义多个子类继承Question类，每个子类都是不同的题型，同样是为了在下次迭代时增加题型做准备。
QuestionPaper类时是试卷类，用来储存试卷的题目，QuestionPaper类中有三种HashMa属性来储存不同的题型，TextPaper类则是用来储存多张答卷；AnswerSheet类则是储存试卷答案，其中也有HashMap属性用来储存答案，利用键值对来与试卷进行绑定。
上述类图还不是很完整，还需定义输出类来对试卷及学生信息进行输出。
总的来说，这一次的作业我并没有花多少心思去完成，更多的是抱着侥幸（那么多人没做那我也不做）
回顾前三次”答题判题程序“作业，我深刻认识到自己在编程能力和问题解决能力上的不足。首先，我在“答题判题程序-4”的实现上缺乏耐心和毅力，导致代码未能完成，这是我对自身责任感和执行力的一次深刻反思。其次，我在代码设计和实现上缺乏经验，没有充分考虑到可扩展性和可维护性，这使得我在面对新的题型和需求时显得力不从心。
2、家居强电电路模拟程序-1
点击查看代码
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
SeriesCircuit circuit = new SeriesCircuit();
Operation operations = new Operation();
InputProcessing input = null;
String line = scanner.nextLine();
while (true) {
if (!line.startsWith("[")) {
break;
}
input = new InputProcessing(line);
if (JudgeEquipment.judge(input.equipmentName) != null)
circuit.addEquipment(JudgeEquipment.judge(input.equipmentName));
line = scanner.nextLine();
}
while (true) {
if (line.equals("end") || !line.startsWith("#")) {
break;
}
input = new InputProcessing(line);
operations.addOperation(input.operation);
line = scanner.nextLine();
}
OperationsProcessing operationsPro = new OperationsProcessing(circuit, operations);
operationsPro.operationsProcessing();
View view = new View(operationsPro.getEquipments());
view.view();
}
}
class OperationsProcessing {
SeriesCircuit circuit = new SeriesCircuit();
Operation operations = new Operation();
List<ElectricEquipment> equipments = new ArrayList<>();
int F = 0;
int L = 0;
public OperationsProcessing(SeriesCircuit circuit, Operation operations) {
this.circuit = circuit;
this.operations = operations;
}
public void operationsProcessing() {
for (ElectricEquipment equipment : circuit.getEquipments()) {
int flag = 0;
for (String operation : operations.getOperation()) {
if (operation.startsWith("K")) {
if (operation.equals(equipment.name)) {
((Switch) equipment).setState();
if (((Switch) equipment).count <= 1) {
equipments.add(equipment);
flag = 1;
}
}
} else if (operation.startsWith("F")) {
F ++;
if (operation.charAt(2) == '+') {
operation = operation.substring(0, operation.length() - 1);
if (operation.equals(equipment.name)) {
((SplitGovernor) equipment).upGear();
if (F <= 1) {
equipments.add(equipment);
flag = 1;
}
}
} else if (operation.charAt(2) == '-') {
operation = operation.substring(0, operation.length() - 1);
if (operation.equals(equipment.name)) {
((SplitGovernor) equipment).downGear();
if (F <= 1) {
equipments.add(equipment);
flag = 1;
}
}
}
} else if (operation.startsWith("L")) {
L ++;
String[] operation1 = operation.split(":");
if (operation1[0].equals(equipment.name)) {
((ContinueGovernor) equipment).setPosition(Double.parseDouble(operation1[1]));
if (L <= 1) {
equipments.add(equipment);
flag = 1;
break;
}
}
}
}
if (flag == 0) {
equipments.add(equipment);
}
}
}
public List<ElectricEquipment> getEquipments() {
return this.equipments;
}
}
class View {
private List<ElectricEquipment> equipments = new ArrayList<>();
private double voltage;
public View(List<ElectricEquipment> equipments) {
this.equipments = equipments;
this.voltage = 220.0;
}
public void view() {
int switchCount = 0;
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
switchCount ++;
}
}
int closedCount = 0;
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
if (((Switch) equipment).getState() == 1) {
closedCount ++;
}
}
}
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
((Switch) equipment).show();
}
}
for (ElectricEquipment equipment1 : equipments) {
if (equipment1.name.startsWith("F")) {
if (switchCount == closedCount)
this.voltage = ((SplitGovernor) equipment1).getOutputVoltage(this.voltage);
((SplitGovernor) equipment1).show();
}
}
for (ElectricEquipment equipment2 : equipments) {
if (equipment2.name.startsWith("L")) {
if (switchCount == closedCount)
this.voltage = ((ContinueGovernor) equipment2).getOutputVoltage(this.voltage);
((ContinueGovernor) equipment2).show();
}
}
for (ElectricEquipment equipment3 : equipments) {
if (equipment3.name.startsWith("B")) {
if (switchCount == closedCount)
((IncandescentLight) equipment3).setVoltage(voltage);
((IncandescentLight) equipment3).show();
}
}
for (ElectricEquipment equipment4 : equipments) {
if (equipment4.name.startsWith("R")) {
if (switchCount == closedCount)
((DaylightLamp) equipment4).setVoltage(voltage);
((DaylightLamp) equipment4).show();
}
}
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("D")) {
if (switchCount == closedCount)
((CeilingFan) equipment).setVoltage(voltage);
((CeilingFan) equipment).show();
}
}
}
}
class Operation {
List<String> operations = new ArrayList<>();
public Operation() {
}
public List<String> getOperation() {
return this.operations;
}
public void addOperation(String operation) {
operations.add(operation);
}
}
class InputProcessing {
protected String equipmentName;
protected String operation;
public InputProcessing(String str) {
if (str.startsWith("[")) {
String[] str11 = str.split("\\[| |\\]");
this.equipmentName = str11[1];
} else if (str.startsWith("#")) {
String[] str22 = str.split("#");
this.operation = str22[1];
}
}
}
class JudgeEquipment {
public JudgeEquipment() {
}
public static ElectricEquipment judge(String str) {
if (str.startsWith("K")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new Switch();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("F")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new SplitGovernor();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("L")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new ContinueGovernor();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("B")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new IncandescentLight();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("R")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new DaylightLamp();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("D")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new CeilingFan();
equipment.name = str1[0];
return equipment;
} else
return null;
}
}
abstract class ElectricEquipment {
protected String name;
protected double pin1;
protected double pin2;
protected double voltage = 0.0;
}
class SeriesCircuit { //串联电路
List<ElectricEquipment> equipments = new ArrayList<>();
public SeriesCircuit() {
}
public void addEquipment(ElectricEquipment equipment) {
equipments.add(equipment);
}
public List<ElectricEquipment> getEquipments() {
return equipments;
}
public void view1() {
for (ElectricEquipment equipment : equipments) {
System.out.println(equipment.name);
}
}
}
class CeilingFan extends ElectricEquipment {//D
private double speed = 0;
private int statu = 0;
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getSpeed() {
if (voltage < 80) {
return 0;
} else if (voltage <= 150) {
return voltage * 4.0 - 240;
} else {
return 360;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getSpeed()));
}
}
class IncandescentLight extends ElectricEquipment {//B
private int brightness;
private int statu = 0;
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getBrightness() {
if (voltage <= 9) {
return 0;
} else if (voltage <= 10) {
return voltage * 50.0 - 450;
} else if (voltage <= 220) {
return voltage * (5 / 7.0) + (300 / 7.0);
} else {
return 200;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getBrightness()));
}
}
class DaylightLamp extends ElectricEquipment {//R
private double brightness = 180;
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getBrightness() {
if (voltage != 0) {
return brightness;
} else {
return 0;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getBrightness()));
}
}
class ContinueGovernor extends ElectricEquipment {//L
private double position = 0.00;
public void setPosition(double position) {
if (position >= 0.0 && position <= 1.0) {
this.position = position;
}
}
public double getPosition() {
return this.position;
}
public double getOutputVoltage(double inputVoltage) {
return getPosition() * inputVoltage;
}
public void show() {
System.out.println("@" + name + ":" + String.format("%.2f", position));
}
}
class SplitGovernor extends ElectricEquipment {//F
private int gear = 0;
public void upGear() {
if (gear < 3)
this.gear ++;
}
public void downGear() {
if (gear > 0)
this.gear --;
}
public double getOutputVoltage(double inputVoltage ) {
switch (gear) {
case 0:
return 0;
case 1:
return inputVoltage * 0.3;
case 2:
return inputVoltage * 0.6;
case 3:
return inputVoltage * 0.9;
default:
return 0;
}
}
public void show() {
System.out.println("@" + name + ":" + gear);
}
}
class Switch extends ElectricEquipment{
protected int count = 1;
private int state = 0;
public void open() {
this.state = 1;
}
public void close() {
this.state = 0;
}
public void setState() {
this.count ++;
if (this.count % 2 == 0) {
this.state = 1;
} else
this.state = 0;
}
public int getState() {
return state;
}
public void show() {
if (state == 1)
System.out.println("@" + name + ":closed");
else
System.out.println("@" + name + ":turned on");
}
}
以下是代码的类图
这次为新的题目”家居强电电路模拟程序-1“，吸取答题判题程序的教训，我设计了很多类用来实现单一职责原则，虽然并不是很好，但比答题判题程序好
通过类图可以知道，我定义了一个抽象电路设备类ElectricEquipment类，这个类是所有电器设备的基类，提供了一些通用的属性和方法。属性包括设备名称（name）、两个端口的电压（pin1和pin2）、当前电压（voltage）。方法包括设置电压（setVoltage）和显示设备信息（show）。后面我将介绍主要的几个类。
SeriesCircuit（串联电路类）:
这个类用于模拟一个串联电路，包含一个电器设备列表。方法包括添加设备（addEquipment）和显示电路中的设备（view1）。
ContinueGovernor（连续调速器类）:
这个类是ElectricEquipment的子类，用于模拟连续调速器的功能。
属性包括当前位置（position）。
方法包括设置位置（setPosition）、获取输出电压（getOutputVoltage）和显示调速器信息（show）。
SplitGovernor（调压器类）:
这个类也是ElectricEquipment的子类，用于模拟分档调速器的功能。
属性包括当前档位（gear）。
方法包括升档（upGear）、降档（downGear）、获取输出电压（getOutputVoltage）和显示调速器信息（show）。
JudgeEquipment（设备判断类）:
这个类用于判断输入的设备名称，返回对应的电器设备实例。
Operation（操作类）:
这个类用于管理用户输入的操作指令，包括添加操作（addOperation）和获取操作列表（getOperation）。
InputProcessing（输入处理类）:
这个类用于处理用户的输入，包括设备信息和操作信息。
View（视图类）:
这个类用于显示电路的当前状态，包括各个设备的信息和电压值。
整体来看，通过定义不同的类来模拟家居电路中的各种设备，每个类都实现了自己的功能，并通过继承和组合的方式来实现相互之间的协作。可以通过输入设备信息和操作指令来与这个模拟电路交互，查看和控制家中的电器设备。
在这次作业中有一点尤须注意，电路中会存在多个开关问题，所以我使用了以下代码来判断开关个数以及闭合开关个数来判断电路是否通路
点击查看代码
int switchCount = 0;
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
switchCount ++;
}
}
int closedCount = 0;
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
if (((Switch) equipment).getState() == 1) {
closedCount ++;
}
}
}
还有输出顺序，输出顺序是按照一定的设备顺序输出，并不是按照电路中设备顺序输出，因此我使用了多个增强for循环以及if语句来判断输出，代码如下
点击查看代码
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("K")) {
((Switch) equipment).show();
}
}
for (ElectricEquipment equipment1 : equipments) {
if (equipment1.name.startsWith("F")) {
if (switchCount == closedCount)
this.voltage = ((SplitGovernor) equipment1).getOutputVoltage(this.voltage);
((SplitGovernor) equipment1).show();
}
}
for (ElectricEquipment equipment2 : equipments) {
if (equipment2.name.startsWith("L")) {
if (switchCount == closedCount)
this.voltage = ((ContinueGovernor) equipment2).getOutputVoltage(this.voltage);
((ContinueGovernor) equipment2).show();
}
}
for (ElectricEquipment equipment3 : equipments) {
if (equipment3.name.startsWith("B")) {
if (switchCount == closedCount)
((IncandescentLight) equipment3).setVoltage(voltage);
((IncandescentLight) equipment3).show();
}
}
for (ElectricEquipment equipment4 : equipments) {
if (equipment4.name.startsWith("R")) {
if (switchCount == closedCount)
((DaylightLamp) equipment4).setVoltage(voltage);
((DaylightLamp) equipment4).show();
}
}
for (ElectricEquipment equipment : equipments) {
if (equipment.name.startsWith("D")) {
if (switchCount == closedCount)
((CeilingFan) equipment).setVoltage(voltage);
((CeilingFan) equipment).show();
}
}
整体来看，这个程序比之前的答题判题程序有了明显改进，但是还是不够好，对类结构设计也还只是学到了皮毛，并不能真正满足需求，但每次都进步一点，就会越来越好！
3、家居强电电路模拟程序-2
点击查看代码
package pta6;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Collections;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
SeriesCircuit seriesCircuit = new SeriesCircuit(); //存equipments
Operation operations = new Operation();
InputProcessing input = null;
InputCircuitProcessing input1 = null;
ParallelCircuitProcessing parallelCircuitProcessing;
String line = scanner.nextLine();
List<ElectricEquipment> allCircuit = new ArrayList<>(); //所有输入的并联支路T，存T
List<ElectricEquipment> allParallels = new ArrayList<>(); //所有的并联支路M
while (true) {
if (!line.startsWith("#T"))
break;
input1 = new InputCircuitProcessing(line);
List<String> circuitEquipment = SplitCircuitEquipment.splitCircuit(input1.parallelCircuit);
parallelCircuitProcessing = new ParallelCircuitProcessing();
allCircuit.add(parallelCircuitProcessing.getSeriesEquipment(circuitEquipment, input1.circuitName));
line = scanner.nextLine();
}
while (true) {
if (!line.startsWith("#M"))
break;
ParallelCircuit parallelCircuits = new ParallelCircuit(); //电路中的并联支路M，存T
SplitSeriesCircuit splitSeriesCircuit = new SplitSeriesCircuit();
input1 = new InputCircuitProcessing(line);
String[] circuits = splitSeriesCircuit.splitCircuit(input1.parallelCircuit);
parallelCircuits.name = input1.circuitName;
for (String name : circuits) {
for (ElectricEquipment circuit : allCircuit) {
if (name.equals(circuit.name)) {
parallelCircuits.getCircuits().add(circuit);
}
}
}
allParallels.add(parallelCircuits);
line = scanner.nextLine();
}
while (true) {
if (!line.startsWith("#T"))
break;
input1 = new InputCircuitProcessing(line);
JudgeEquipment judgeEquipment = new JudgeEquipment(allCircuit, allParallels);
List<String> inputEquipments = SplitCircuitEquipment.splitCircuit(input1.parallelCircuit);
for (String inputEquipment : inputEquipments) {
input = new InputProcessing(inputEquipment);
if (judgeEquipment.judge(input.equipmentName) != null)
seriesCircuit.addEquipment(judgeEquipment.judge(input.equipmentName));
}
line = scanner.nextLine();
}
while (true) { //用来进行#K1等操作的输入
if (line.equals("end") || !line.startsWith("#")) {
break;
}
input = new InputProcessing(line);
operations.addOperation(input.operation);
line = scanner.nextLine();
}
OperationsProcession_1 operationsPro = new OperationsProcession_1();
seriesCircuit = operationsPro.operationsProcessing(seriesCircuit, operations);
Calculation calculation = new Calculation(seriesCircuit);
seriesCircuit = calculation.ResistanceCalculation(seriesCircuit);
seriesCircuit = calculation.calculation(seriesCircuit);
//View.view(seriesCircuit);
for (ElectricEquipment equipment : seriesCircuit.getEquipments()) {
System.out.println(equipment.name);
}
}
}
class Calculation {
SeriesCircuit seriesCircuit = new SeriesCircuit();
Calculate calculate = new Calculate();
public Calculation(SeriesCircuit seriesCircuit) {
this.seriesCircuit = seriesCircuit;
}
public SeriesCircuit ResistanceCalculation(SeriesCircuit seriesCircuit) {
seriesCircuit = (SeriesCircuit) calculate.calculateResistance(seriesCircuit);
return seriesCircuit;
}
public SeriesCircuit calculation(SeriesCircuit seriesCircuit) {
SeriesCircuit newSeriesCircuit = new SeriesCircuit();
double voltage = 220.0;
int switchCount = 0; //开关个数
for (ElectricEquipment equipment : seriesCircuit.getEquipments()) {
if (equipment.name.startsWith("K")) {
switchCount ++;
}
}
int closedCount = 0; //闭合状态的开关个数
for (ElectricEquipment equipment : seriesCircuit.getEquipments()) {
if (equipment.name.startsWith("K")) {
if (((Switch) equipment).getState() == 1) {
closedCount ++;
}
}
}
for (ElectricEquipment equipment : seriesCircuit.getEquipments()) {
if (equipment.name.startsWith("M")) {
for (ElectricEquipment equipment1 : ((ParallelCircuit) equipment).getCircuits()) {
equipment1 = calculation((SeriesCircuit) equipment1);
for (ElectricEquipment equipment2 : ((SeriesCircuit) equipment1).getEquipments()) {
newSeriesCircuit.addEquipment(equipment2);
}
}
} else if (equipment.name.startsWith("T")) {
equipment = calculation((SeriesCircuit) equipment);
for (ElectricEquipment equipment2 : ((SeriesCircuit) equipment).getEquipments()) {
newSeriesCircuit.addEquipment(equipment2);
}
} else {
if (switchCount == closedCount) {
equipment = calculate.calculate(equipment, voltage, seriesCircuit.resistance);
newSeriesCircuit.addEquipment(equipment);
}
}
}
return newSeriesCircuit;
}
}
class Calculate {
public ElectricEquipment calculate(ElectricEquipment equipment, double v, double r) {
if (equipment.name.startsWith("F")) {
v = ((SplitGovernor) equipment).getOutputVoltage(v);
} else if (equipment.name.startsWith("L")) {
v = ((ContinueGovernor) equipment).getOutputVoltage(v);
} else if (equipment.name.startsWith("B")) {
v = v * (equipment.resistance / (r * 1.0));
((IncandescentLight) equipment).setVoltage(v);
} else if (equipment.name.startsWith("R")) {
v = v * (equipment.resistance / (r * 1.0));
((DaylightLamp) equipment).setVoltage(v);
} else if (equipment.name.startsWith("D")) {
v = v * (equipment.resistance / (r * 1.0));
((CeilingFan) equipment).setVoltage(v);
} else if (equipment.name.startsWith("A")) {
v = v * (equipment.resistance / (r * 1.0)); //equipment.resistance //calculateResistance(equipment).resistance
((FloorFan) equipment).setVoltage(v);
}
return equipment;
}
public ElectricEquipment calculateResistance(ElectricEquipment T) {
double resistance = 0;
Calculate calculate = new Calculate();
for (ElectricEquipment equipment : ((SeriesCircuit) T).getEquipments()) {
double resistance_d = 0;
if (equipment.name.startsWith("M")) {
for (ElectricEquipment equipment1 : ((ParallelCircuit) equipment).getCircuits()) {
equipment1 = calculate.calculateResistance(equipment1);
resistance_d += 1.0 / equipment1.resistance;
}
resistance += 1.0 / resistance_d;
} else if (equipment.name.startsWith("T")) {
equipment = calculate.calculateResistance(equipment);
resistance += equipment.resistance;
} else {
resistance += equipment.resistance;
}
}
T.resistance = resistance;
return T;
}
}
class OperationsProcession_1 {
private double voltage = 220.0;
SeriesCircuit seriesCircuit = new SeriesCircuit();
public SeriesCircuit operationsProcessing(SeriesCircuit circuit, Operation operations) {
for (ElectricEquipment equipment : circuit.getEquipments()) {
if (equipment.name.startsWith("T")) {
SeriesCircuit circuit1 = new SeriesCircuit();
for (ElectricEquipment equipment1 : ((SeriesCircuit) equipment).getEquipments()) {
operate(equipment1, operations);
circuit1.addEquipment(equipment1);
}
seriesCircuit.addEquipment(circuit1);
} else if (equipment.name.startsWith("M")) {
ParallelCircuit circuis = new ParallelCircuit();
for (ElectricEquipment circuit1 : ((ParallelCircuit) equipment).getCircuits()) {
SeriesCircuit circuit2 = new SeriesCircuit();
for (ElectricEquipment equipment1 : ((SeriesCircuit) circuit1).getEquipments()) {
operate(equipment1, operations);
circuit2.addEquipment(equipment1);
}
circuit2.name = circuit1.name;
circuis.addCircuit(circuit2);
}
circuis.name = equipment.name;
seriesCircuit.addEquipment(circuis);
} else {
operate(equipment, operations);
seriesCircuit.addEquipment(equipment);
}
}
return seriesCircuit;
}
public void operate(ElectricEquipment equipment, Operation operations) {
for (String operation : operations.getOperation()) {
if (operation.startsWith("K")) {
if (operation.equals(equipment.name))
((Switch) equipment).setState();
} else if (operation.startsWith("F")) {
if (operation.charAt(2) == '+') {
operation = operation.substring(0, operation.length() - 1);
if (operation.equals(equipment.name))
((SplitGovernor) equipment).upGear();
} else if (operation.charAt(2) == '-') {
operation = operation.substring(0, operation.length() - 1);
if (operation.equals(equipment.name))
((SplitGovernor) equipment).downGear();
}
} else if (operation.startsWith("L")) {
String[] operation1 = operation.split(":");
if (operation1[0].equals(equipment.name))
((ContinueGovernor) equipment).setPosition(Double.parseDouble(operation1[1]));
}
}
}
}
class View { //打印出数据
public static void view(SeriesCircuit equipments) { //打印数据
for (ElectricEquipment equipment : equipments.getEquipments()) {
if (equipment.name.startsWith("K")) {
((Switch) equipment).show();
}
}
for (ElectricEquipment equipment1 : equipments.getEquipments()) {
if (equipment1.name.startsWith("F")) {
((SplitGovernor) equipment1).show();
}
}
for (ElectricEquipment equipment2 : equipments.getEquipments()) {
if (equipment2.name.startsWith("L")) {
((ContinueGovernor) equipment2).show();
}
}
for (ElectricEquipment equipment3 : equipments.getEquipments()) {
if (equipment3.name.startsWith("B")) {
((IncandescentLight) equipment3).show();
}
}
for (ElectricEquipment equipment4 : equipments.getEquipments()) {
if (equipment4.name.startsWith("R")) {
((DaylightLamp) equipment4).show();
}
}
List<ElectricEquipment> equipments5 = new ArrayList<>();
for (ElectricEquipment equipment : equipments.getEquipments()) {
if (equipment.name.startsWith("D")) {
equipments5.add(equipment);
//((CeilingFan) equipment).show();
}
}
Collections.sort(equipments5, new Comparator<ElectricEquipment>() {
@Override
public int compare(ElectricEquipment e1, ElectricEquipment e2) {
return e1.name.compareTo(e2.name);
}
});
for (ElectricEquipment equipment : equipments5) {
((CeilingFan) equipment).show();
}
for (ElectricEquipment equipment : equipments.getEquipments()) {
if (equipment.name.startsWith("A")) {
((FloorFan) equipment).show();
}
}
}
}
class Operation { //储存输入的操作的类，比如#K，#F++，#L:0.68
List<String> operations = new ArrayList<>();
public Operation() {
}
public List<String> getOperation() {
return this.operations;
}
public void addOperation(String operation) {
operations.add(operation);
}
}
class InputCircuitProcessing { //处理并联电路
protected String circuitName;
protected String parallelCircuit;
public InputCircuitProcessing(String str) {
String[] str1 = str.split("#");
String[] str2 = str1[1].split(":");
this.circuitName = str2[0];
this.parallelCircuit = str2[1];
}
}
class InputProcessing { //处理输入的字符串
protected String equipmentName;
protected String operation;
public InputProcessing(String str) {
if (str.startsWith("[")) {
String[] str11 = str.split("\\[| |\\]");
this.equipmentName = str11[1];
} else if (str.startsWith("#")) {
String[] str22 = str.split("#");
this.operation = str22[1];
}
}
}
class SplitCircuitEquipment {
public static List<String> splitCircuit(String str) {
//String[] circuitEquipment = str.split(" ");
// 编译正则表达式，匹配方括号内的内容
Pattern pattern = Pattern.compile("\\[(.*?)\\]");
Matcher matcher = pattern.matcher(str);
// 使用ArrayList来存储分割后的字符串
List<String> circuitEquipment = new ArrayList<>();
// 循环查找所有匹配项，并存储到ArrayList中
while (matcher.find()) {
circuitEquipment.add(matcher.group());
}
return circuitEquipment;
}
}
class SplitSeriesCircuit { //分离输入#M中的电路各个T
public String[] splitCircuit(String circuits) {
String[] circuit = circuits.split("\\[| |\\]");
String[] newCiecuits = new String[circuit.length - 1];
System.arraycopy(circuit, 1, newCiecuits, 0, circuit.length - 1);
return newCiecuits;
}
}
class ParallelCircuitProcessing {
SeriesCircuit seriesEquipments = new SeriesCircuit();
InputProcessing input = null;
public SeriesCircuit getSeriesEquipment(List<String> circuitEquipment, String name) {
JudgeEquipment judgeEquipment1 = new JudgeEquipment();
seriesEquipments.name = name;
for (String line : circuitEquipment) {
input = new InputProcessing(line);
if (judgeEquipment1.judge(input.equipmentName) != null)
seriesEquipments.addEquipment(judgeEquipment1.judge(input.equipmentName));
}
return seriesEquipments;
}
}
class JudgeEquipment {
List<ElectricEquipment> allCircuit;
List<ElectricEquipment> allParallel;
public JudgeEquipment(List<ElectricEquipment> allCircuit, List<ElectricEquipment> allParallel) {
this.allCircuit = allCircuit;
this.allParallel = allParallel;
}
public JudgeEquipment() {
}
public ElectricEquipment judge(String str) {
if (str.startsWith("K")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new Switch();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("F")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new SplitGovernor();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("L")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new ContinueGovernor();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("B")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new IncandescentLight();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("R")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new DaylightLamp();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("D")) {
String[] str1 = str.split("-");
ElectricEquipment equipment = new CeilingFan();
equipment.name = str1[0];
return equipment;
} else if (str.startsWith("M")) {
String[] str1 = str.split("-");
return judgeCircuitM(str1[0]);
} else
return null;
}
public ElectricEquipment judgeCircuitM(String circuitName) {
for (ElectricEquipment Parallel : allParallel) {
if (circuitName.equals(Parallel.name)) {
return Parallel;
}
}
return null;
}
}
abstract class ElectricEquipment { //所有电路设备的父类，属于抽象类
protected String name;
protected double pin1;
protected double pin2;
protected double voltage = 0.0;
protected double resistance;
}
abstract class ControlEquipment extends ElectricEquipment {
}
abstract class ControlledEquipment extends ElectricEquipment {
}
class AllParallelCircuit extends ElectricEquipment { //并联电路集合M
List<ElectricEquipment> parallelCircuits = new ArrayList<>();
public void addparallelCircuit(ParallelCircuit parallelCircuit) {
parallelCircuits.add(parallelCircuit);
}
public List<ElectricEquipment> getParallelCircuits() {
return parallelCircuits;
}
}
class ParallelCircuit extends ElectricEquipment { //并联电路
protected int state = 0;
List<ElectricEquipment> circuits = new ArrayList<>(); //存SeriesCircuit串联电路
public void addCircuit(SeriesCircuit circuit) {
circuits.add(circuit);
}
public List<ElectricEquipment> getCircuits() {
return circuits;
}
}
class SeriesCircuit extends ElectricEquipment { //串联电路，用来储存电路中的各个设备
protected int state = 0;
List<ElectricEquipment> equipments = new ArrayList<>(); //存设备
public void addEquipment(ElectricEquipment equipment) {
equipments.add(equipment);
}
public List<ElectricEquipment> getEquipments() {
return equipments;
}
}
class CeilingFan extends ControlledEquipment {//吊扇类
private double speed = 0;
private int statu = 0;
public CeilingFan() {
resistance = 20;
}
public Double getSpeed() {
return speed;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public void setSpeed() {
if (voltage < 80) {
this.speed = 0;
} else if (voltage <= 150) {
this.speed = voltage * 4.0 - 240;
} else {
this.speed = 360;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getSpeed()));
}
}
class FloorFan extends ControlledEquipment { //落地扇类 A
private double speed = 0;
private int statu = 0;
public FloorFan() {
resistance = 20;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getSpeed() {
return speed;
}
public void setSpeed() {
if (voltage >= 80 && voltage < 100) {
this.speed = 80;
} else if (voltage >= 100 && voltage < 120) {
this.speed = 160;
} else if (voltage >= 120 && voltage < 140) {
this.speed = 260;
} else if (voltage >= 140) {
this.speed = 360;
} else
this.speed = 0;
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getSpeed()));
}
}
class IncandescentLight extends ControlledEquipment {//白炽灯类
private double brightness;
private int statu = 0;
public IncandescentLight() {
resistance = 10;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getBrightness() {
return brightness;
}
public void setBrightness() {
if (voltage <= 9) {
this.brightness = 0;
} else if (voltage <= 10) {
this.brightness = voltage * 50.0 - 450;
} else if (voltage <= 220) {
this.brightness = voltage * (5 / 7.0) + (300 / 7.0);
} else {
this.brightness = 200;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getBrightness()));
}
}
class DaylightLamp extends ControlledEquipment {//日光灯类
private double brightness = 180;
public DaylightLamp() {
resistance = 5;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public double getBrightness() {
return this.brightness;
}
public void setBrightness() {
if (voltage != 0) {
this.brightness = brightness;
} else {
this.brightness = 0;
}
}
public void show() {
System.out.println("@" + name + ":" + (int) Math.floor(getBrightness()));
}
}
class ContinueGovernor extends ControlEquipment {//连续调速器类
private double position = 0.00;
public void setPosition(double position) {
if (position >= 0.0 && position <= 1.0) {
this.position = position;
}
}
public double getPosition() {
return this.position;
}
public double getOutputVoltage(double inputVoltage) {
return getPosition() * inputVoltage;
}
public void show() {
System.out.println("@" + name + ":" + String.format("%.2f", position));
}
}
class SplitGovernor extends ControlEquipment {//分档调速器类
private int gear = 0;
public void upGear() {
if (gear < 3)
this.gear ++;
}
public void downGear() {
if (gear > 0)
this.gear --;
}
public double getOutputVoltage(double inputVoltage ) {
switch (gear) {
case 0:
return 0;
case 1:
return inputVoltage * 0.3;
case 2:
return inputVoltage * 0.6;
case 3:
return inputVoltage * 0.9;
default:
return 0;
}
}
public void show() {
System.out.println("@" + name + ":" + gear);
}
}
class Switch extends ControlEquipment {//开关类
protected int count = 1;
private int state = 0;
public void open() {
this.state = 1;
}
public void close() {
this.state = 0;
}
public void setState() {
this.count ++;
if (this.count % 2 == 0) {
this.state = 1;
} else
this.state = 0;
}
public int getState() {
return state;
}
public void show() {
if (state == 1)
System.out.println("@" + name + ":closed");
else
System.out.println("@" + name + ":turned on");
}
}
以下是代码的类图
这次的“家居强电电路模拟程序-2”在“家居强电电路模拟程序-1”的基础上迭代增加了新的落地扇，并增加了并联电路，难度上升
这次的作业给电路设备新增了电阻这一属性，并且输入的格式发生变化，因此需要新增类来处理变化。
通过类图可以看出，这次的类增加了许多，也变得更加复杂，耦合性比较强，因为个人能力有限，无法做到更好，并且这次作业并没有拿到分数，问题主要出在输出问题以及电路中各个设备的计算，输出的设备数值均为初始值并没有完成计算步骤。
先来分析新增的几个重要的类：
InputCircuitProcessing（输入电路处理类）:
这个类用于处理并联电路的输入字符串。
它包含一个方法获取串联电路设备（getSeriesEquipment），该方法接收一个字符串列表，代表电路组件，以及一个新的系列电路的名称，然后返回一个包含这些组件的 SeriesCircuit 对象。
InputProcessing（输入处理类）:
这个类用于处理输入的字符串，判断是设备还是操作。
它包含两个属性：设备名称（equipmentName）和输入操作（operation），分别用于存储设备的名称和操作的命令。
包含一个方法，用于解析输入字符串，判断其类型，并设置属性 equipmentName 和 operation。
SplitCircuitEquipment（分割电路设备类）:
这个类包含一个静态方法 splitCircuit，该方法接收一个字符串，并返回一个字符串列表，代表方括号内的电路组件。这个方法使用正则表达式来匹配方括号内的内容，并将匹配到的内容添加到列表中。
ParallelCircuitProcessing（并联电路处理类）:
这个类用于处理并联电路的设备。它包含一个属性串联电路设备（seriesEquipments），用于存储并联电路中的串联电路设备。这个类还包含一个方法获取串联电路设备（getSeriesEquipment），该方法接收一个字符串列表，代表电路组件，以及一个新的系列电路的名称，然后返回一个包含这些组件的 SeriesCircuit 对象。这个方法使用了JudgeEquipment类来判断每个组件的类型，并添加到串联电路中。
JudgeEquipment（设备判断类）:
这个类经过修改后，用于判断输入的字符串代表的设备类型。它包含两个列表 allCircuit 和 allParallel，用于存储所有电路设备和并联电路设备。
包含一个方法判断电路设备（judge），该方法接收一个代表设备或操作的字符串，如果它是一个已知的设备，则返回相应的 ElectricEquipment 对象，如果它没有被识别，则返回 null。此外，还有一个方法 judgeCircuitM，用于判断并联电路中的电路名称是否匹配已知的并联电路设备。
Calculation（计算类）:
这个类包含一个串SeriesCircuit 类型的属性 seriesCircuit 和一个 Calculate 类型的属性 calculate。
方法 ResistanceCalculation接收一个 SeriesCircuit 对象，调用 calculate 类的 calculateResistance 方法来计算电路的电阻，并返回更新后的 SeriesCircuit 对象。
方法 calculation接收一个 SeriesCircuit 对象，并进行一系列计算操作。它首先遍历电路中的所有设备，根据设备类型和电路状态进行相应的计算。这个方法还涉及到递归调用 calculation 方法来处理并联电路中的设备。最终，它返回一个新的 SeriesCircuit 对象，其中包含了计算后的设备。
Calculate（计算辅助类）:
这个类包含多个用于计算电路参数的方法。
方法 calculate接收一个 ElectricEquipment 对象、电压 v 和电阻 r，根据设备类型执行不同的计算，并返回更新后的 ElectricEquipment 对象。
方法 calculateResistance(ElectricEquipment T) 接收一个 ElectricEquipment 对象，计算并返回该设备的电阻。这个方法涉及到递归地调用 calculateResistance 来处理并联电路中的设备，并将它们的电阻相加。
回到问题所在，设备无法获取经过计算后的数据主要出现在Calculation类和Calculate类中，这个问题我将会在接下来的迭代题目中将其解决。
总的来说，”家居强电电路模拟程序-2“通过引入新的设备、增加并联电路的支持和新增电阻属性，使得电路模拟更加真实和复杂。但因为”家居强电电路模拟程序-2“的类结构设计并不是很好，所以在迭代修改时还是有点困难，这尤其体现出好的类结构设计的重要性。所以我决定在接下来的题目中，重新设计类结构，尽量遵循开闭原则、单一职责原则以及里氏替换原则等原则，给出一个良好设计的类结构。
三、踩坑心得
在进行类结构设计与写代码时，我遇到了许多问题，也从中吸取了许多教训。以下是我的一些踩坑心得：
1、耐心和毅力至关重要：我常常因为遇到难题而感到沮丧，甚至想要放弃。但是，只有坚持下去，才能解决问题，提高自己的能力。
2、良好的设计原则：在设计类结构时，遵循良好的设计原则非常重要。这些原则包括单一职责原则、开闭原则、里氏替换原则等。它们可以帮助我们创建出可扩展、可维护的代码。
3、模块化设计：将系统划分为独立的、可替换的模块，可以提高代码的可维护性和可扩展性。每个模块都应该有一个清晰定义的功能，并且与其他模块的耦合度尽量低。
4、考虑未来的需求：在设计类结构时，要考虑到未来的需求，为可能的扩展留下空间。例如，我可以为处理不同题型的类留出扩展点，以应对未来的题目变化。
5、不断学习和改进：在设计类结构时，我意识到自己的能力还有很大的提升空间。我需要不断学习，了解更多的设计模式和原则，以便在遇到问题时能够更好地解决问题。
6、代码审查和测试：在完成类结构设计后，进行代码审查和测试非常重要。这可以帮助我发现潜在的问题，并及时修复。
总的来说，软件工程是一个需要耐心、学习和实践的过程。通过不断地尝试和改进，我相信我会成为一个更好的程序员。
四、改进建议
1、使用抽象类：定义清晰的抽象类，可以让更容易地扩展新的题型或设备。当需要添加新功能时，可以直接创建一个新的子类，而不用修改现有的类。
2、降低耦合度：尽量减少类之间的依赖关系，比如定义一个控制类Control或管理类Agent这样可以更容易地修改和维护代码。
3、代码复用：尽量代码复用，这样可以减少代码冗余，并使代码更加清晰。
4、学习和应用设计模式：这一点很重要，了解并应用设计模式，可以帮助解决常见的设计问题，并提高代码的可维护性与可扩展性。
5、调试代码：学会使用调试工具，如断点调试、日志输出等，可以帮助更快地找到并修复错误。
6、基础语法：熟练掌握基础语法，学会使用各种包中的类和方法，可以有效的帮助我们完成代码。
五、总结
在PTA作业的第二阶段，我主要写了三个程序的设计与实现，这三个程序分别为“答题判题程序-4”、“家居强电电路模拟程序-1”及其迭代版本“家居强电电路模拟程序-2”。在这个过程中，我深刻认识到自己在编程能力和问题解决能力上的不足，并从中吸取了许多教训。
首先，我在电路模拟程序的设计与实现上取得了显著的成长。在这三次作业中，我从零开始，逐步构建和完善了电路模拟系统，这个过程让我深刻体会到了编程、类结构设计以及问题解决的重要性。
其次，我在“答题判题程序-4”的实现上缺乏耐心和毅力，导致代码未能完成。这让我意识到耐心和毅力对于解决问题的重要性。我在代码设计和实现上缺乏经验，没有充分考虑到可扩展性和可维护性。因此，在“家居强电电路模拟程序”的设计中，我吸取了答题判题程序的教训，设计了很多类来实现单一职责原则。
最后，我也意识到自己在编程能力和问题解决能力上还存在不足。在实际编写代码时，我常常因为能力有限而无法达到预期的效果。这让我深刻反思，认识到我需要不断学习和改进，提升自己的编程技能和问题解决能力。
总的来说，这次PTA作业让我收获颇丰。我不仅更深刻的认识了类结构设计以及如何设计出良好的类结构，更学会了如何提升自己的编程能力和问题解决能力。