首页 > 其他分享 >第二次Bolg

第二次Bolg

时间：2024-06-09 10:11:46浏览次数：20  
标签：String Bolg void devices else new 第二次 public

1.前言
知识点：题目集4：类间的关系，关联，依赖，聚集，继承，正则表达式，Map,List接口
题目集5：类间的关系，关联，依赖，聚集，继承，正则表达式，List，Map，ArrayList,Collection,迭代器。
题目集6：类间的关系，关联，依赖，聚集，继承，正则表达式，抽象类，抽象方法，abstract，List,Map.
题量：题目集4：正常，答题判断程序代码要求良较高。
题目集5：正常。
题目集6：正常，只有家庭电路类程序设计
难度：题目集4：答题判断程序难度为困难，题目难度太高
题目集5：难度适中，模拟家庭电路难度较高，比另外两题难得多
题目集6：困难，迭代题目集5的模拟家庭电路程序，难度很高
2.设计与分析
题目集4
题目内容：设计实现答题程序，模拟一个小型的测试，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。
（由于本次题目集答题判断程序并没有完成，所以只写了部分代码，在这里简单的展示出来）
整体类图：

类设计及其分析：
（1）设计AnswerPaper类，保存和处理一张答卷的信息。
部分源码：
public class AnswerPaper {
private TestPaper paper;
private String[] answers;
private boolean[] marks;

public AnswerPaper() {
	// TODO Auto-generated constructor stub
}

/**
 * @param paper
 */
public AnswerPaper(TestPaper paper) {
	super();
	this.paper = paper;
}
public boolean getMarks(int index) {
    return marks[index];
}

public void setMarks(int index, boolean value) {
    marks[index] = value;
}
public String getAnswers(int index) {
    return answers[index];
}
public void setAnswers(int index, String value) {
    answers[index] = value;
}


public boolean getJudge(int num) {
	if(paper.getQuestion(num).matchingStandardAnswers(answers[num])) {
		return true;
	}
	else {
		return false;
	}
}

输出题目中错误信息的方法public void printErrorNumQuestion(Answer answer);
输出失效题目信息的方法pubic void printInvalidquestion(Answer answer);
（2）设计Answer类，用于保存答卷中一道答案的信息。
部分源码：
public class Answer {
private Question_Paper question = new Question_Paper();
private String answer;
private boolean mark = true;
private int score = 0;

public Answer() {
	// TODO Auto-generated constructor stub
}


/**
 * @param question
 * @param answer
 */
public Answer(Question_Paper question, String answer) {
	super();
	this.question = question;
	this.answer = answer;
}

}
获得总分的办法public void getSum();
（3）设计Question类，用于保存一道题目的信息以及处理的方法。
部分源码：

public void setP_q_num(int p_q_num) {
	this.p_q_num = p_q_num;
}

public Question getQuestion() {
	return question;
}

public void setQuestion(Question question) {
	this.question = question;
}

public int getQuestionScore() {
	return questionScore;
}

public void setQuestionScore(int questionScore) {
	this.questionScore = questionScore;
}
public int jude_markAnswer(String answer) {
	
}

加入设计属性ArrayList answewrs = new ArrayList<>(); 记录所有引用该题目的答案；
(4)设计Question_Paper类，用于保存试卷中的题目信息。
部分源码：
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}

public boolean isValid() {
	return isValid;
}
public void setValid(boolean isValid) {
	this.isValid = isValid;
}
public boolean matchingStandardAnswers(String answer) {
	if(answer.equals(this.standardAnswer)) {
		return true;
	}
	else return false;
}
public void isValid(String input) {
	if (!input.matches("#N:\\\\d+ #Q:.+ #A:.+")) {
        this.isValid = false;
    } else {
        this.isValid = true;
    }
}

判断题目得分的方法public int judje_markAnswewr(String answer)
(5)设计Student类，保存学生的信息
部分源码：
public class Student {
private String No;
private String Name;

public Student() {
	// TODO Auto-generated constructor stub
}

/**
 * @param no
 * @param name
 */
public Student(String no, String name) {
	super();
	No = no;
	Name = name;
}

public String getNo() {
	return No;
}

public void setNo(String no) {
	No = no;
}

public String getName() {
	return Name;
}

保存基本的学生信息和答题卡信息
题目集5
题目内容：智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。
整体类图：

类设计及其分析：
（1）设计Circuit类
部分源码：
class Circuit {
private Map<String, CircuitDevice> devices = new LinkedHashMap<>();
private Map<String, ControlledDevice> controlledDevices = new HashMap<>();
public void addDevice(CircuitDevice circuitDevice) {
devices.put(circuitDevice.getNumber(), circuitDevice);
}
public void addControlledDevice(CircuitDevice circuitDevice) {
controlledDevices.put(circuitDevice.getNumber(), (ControlledDevice) circuitDevice);
}
public void controlCommend(String str) {
String number = str.substring(1,3);
CircuitDevice device = devices.get(number);
if (device instanceof Switch) {
((Switch) device).toggle();
((Switch) device).setVoltage();
for (ControlledDevice conedDevice : controlledDevices.values()) {
if(isVoltageZero()) {
conedDevice.setInputVoltage(((Switch) device).getVoltage());
}
else conedDevice.setInputVoltage(0);
}
} else if (device instanceof BinningGovernor) {
if (str.substring(3,4).equals("+")) {
((BinningGovernor) device).upGear();
((BinningGovernor) device).setVoltage();
for (ControlledDevice conedDevice : controlledDevices.values()) {
conedDevice.setInputVoltage(((BinningGovernor) device).getVoltage());
}
}else if (str.substring(3,4).equals("-")) {
((BinningGovernor) device).downGear();
((BinningGovernor) device).setVoltage();
for (ControlledDevice conedDevice : controlledDevices.values()) {
conedDevice.setInputVoltage(((BinningGovernor) device).getVoltage());
}
}
}
else if (device instanceof ContinuousGovernor) {
((ContinuousGovernor) device).setGearParameters((Double.parseDouble(str.substring(4))));
((ContinuousGovernor) device).setVoltage();
for (ControlledDevice conedDevice : controlledDevices.values()) {
conedDevice.setInputVoltage(((ContinuousGovernor) device).getVoltage());
}
}
}
}
使用 Map<String, CircuitDevice> devices = new LinkedHashMap<>();设置一个可以储存所有电器元件的链表。
使用 Map<String, ControlledDevice> controlledDevices = new HashMap<>();设置一个可以储存所有受控设备的链表，从而方便设置电压。
使用 public void controlCommend(String str);方法，对设备进行调控，并且设置相应的电压。
设置不同受控设备的List链表，从而可以在show方法中可以对受控设备实现与题目意思相同的，依次输出相应的状态。
（2）设计CircuitDevice类，为所有电器的父类。
部分源码：
abstract class CircuitDevice {
protected String number;
/**
* @param number
*/
public CircuitDevice(String number) {
this.number = number;
}
}
属性中只有编号
（3）设计ControlledDevice类，此为受控设备类，继承自电器设备类
部分源码：
abstract class ControlledDevice extends CircuitDevice{
protected double inputVoltage = 220;

public ControlledDevice(String number) {
	super(number);
	// TODO Auto-generated constructor stub
}

}
此类中实现抽象show方法，从而实现不同的设备都可以输出不同的状态
（4）设计ControlDevice类，此为控制设备类，继承自电器设备类
部分源码：
abstract class ControlDevice extends CircuitDevice{
protected double voltage;

public ControlDevice(String number) {
	super(number);
}
public double getVoltage() {
	return voltage;
}
public void setVoltage(double voltage) {
	this.voltage = voltage;
}

public abstract void setVoltage();

}
此类实现控制设备对受控设备电压的控制，实现了抽象方法setVoltage;
(5)设计Switch,BinningGovernor,ContinuousGovernor,这些为控制设备类，继承自ControlDevice类，不同的控制设备可实现不同的电压控制效果
(6)设计IncandescentLamp，FluorescentLamp，CeilingFan类，这些为受控设备类，可以实现不同电器的效果。
（7）测试类，Main类
部分源码：
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Circuit devices = new Circuit();
String str;
do{
str = input.next();
if(str.startsWith("[")) {
if(str.startsWith("[VCC")) {
continue;
}
else {
String num = str.substring(1, 2);
String number = str.substring(1, 3);
if(num.equals("K")) {
Switch aSwitch = new Switch(number);
devices.addDevice(aSwitch);
}else if(num.equals("F")) {
BinningGovernor binningGovernor = new BinningGovernor(number);

					devices.addDevice(binningGovernor);
				}else if(num.equals("L")) {
					ContinuousGovernor continuousGovernor = new ContinuousGovernor(number);
					devices.addDevice(continuousGovernor);
				}else if(num.equals("B")) {
					IncandescentLamp incandescentLamp = new IncandescentLamp(number);
					devices.addDevice(incandescentLamp);
					devices.addControlledDevice(incandescentLamp);
				}else if(num.equals("R")) {
					FluorescentLamp fluorescentLamp = new FluorescentLamp(number);
					devices.addDevice(fluorescentLamp);
					devices.addControlledDevice(fluorescentLamp);
				}else if(num.equals("D")) {
					CeilingFan ceilingFan = new CeilingFan(number);
					devices.addDevice(ceilingFan);
					devices.addControlledDevice(ceilingFan);
				}
				
			}
		}
		else if(str.startsWith("#")) {
			devices.controlCommend(str);
		}	
	}while(!str.equals("end"));

}
首先如果由"["开头，则为电路，如果有"#"开头，则为控制器调控，添加不同的电器并实现相应的调控，完成整个电路的运作。
题目集6
题目内容：智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。
整体类图：

类设计及其分析：
（1）设计Circuit类
部分源码：
class Circuit {
private Map<String, CircuitDevice> devices = new LinkedHashMap<>();
private Map<String, CircuitDevice> mainDevices = new HashMap<>();
private Map<String, SeriesCircuit> seriesCircuits = new HashMap<>();
private double Voltage = 220;
public double getVoltage() {
return Voltage;
}
public void controlCommend(String str) {
String number = str.substring(1,3);
for(String key : mainDevices.keySet()) {
if(key.equals(number)) {
CircuitDevice device = mainDevices.get(number);
if (device instanceof Switch) {
((Switch) device).toggle();
}else if (device instanceof BinningGovernor) {
if (str.substring(3,4).equals("+")) {
((BinningGovernor) device).upGear();
this.Voltage = ((BinningGovernor) device).getVoltage(220);
}else if (str.substring(3,4).equals("-")) {
((BinningGovernor) device).downGear();
this.Voltage = ((BinningGovernor) device).getVoltage(220);
}
}else if (device instanceof ContinuousGovernor) {
((ContinuousGovernor) device).setGearParameters((Double.parseDouble(str.substring(4))));
this.Voltage = ((ContinuousGovernor) device).getVoltage(220);
}
}
else {
CircuitDevice device = devices.get(number);

			if (device instanceof Switch) {
				((Switch) device).toggle();	System.out.println("00000");				
			}						
		}
	}	
	if(!mianClosure()) {
		this.Voltage = 0;
	}								
}
public void setWay() {
	for(SeriesCircuit seriesCircuit : seriesCircuits.values()) {
		seriesCircuit.setPathways();
		//seriesCircuit.show();
		}	
}
private boolean mianClosure() {
	boolean t = true;
	for(CircuitDevice device : mainDevices.values()) {
		if(device instanceof Switch) {
			Switch switchDevice = (Switch) device;
			if(!switchDevice.isClosure()) {
				t = false;
				break;
			}
		}
	}
	return t;
}
public void calculatePartialPressure() {
	double totalR = 0;
	for(CircuitDevice mainDevice : mainDevices.values()) {
		totalR += mainDevice.getResistance();
	}	
	for(CircuitDevice mainDevice : mainDevices.values()) {
		if(mainDevice instanceof ControlledDevice) {				
			if(mainDevice instanceof ParallelCircuit) {
				ParallelCircuit parallelCircuit = (ParallelCircuit) mainDevice;
				parallelCircuit.setPathways();
				//System.out.println(parallelCircuit.isPathways());
				if(!parallelCircuit.isPathways()) {
					parallelCircuit.setInputVoltage(0);
					parallelCircuit.setV();
					this.Voltage = 0;

public void show() {
// 按照指定的顺序输出设备状态
List switchDevices = switchDevices();
switchDevices.sort(Comparator.comparing(Switch::getNumber));
for (Switch switchDevice : switchDevices) {
switchDevice.display();
}

    List<BinningGovernor> binningGovernors = binningGovernors();
    binningGovernors.sort(Comparator.comparing(BinningGovernor::getNumber));
    for (BinningGovernor binningGovernor : binningGovernors) {
        binningGovernor.display();
    }

    List<ContinuousGovernor> continuousGovernors = continuousGovernors();
    continuousGovernors.sort(Comparator.comparing(ContinuousGovernor::getNumber));
    for (ContinuousGovernor continuousGovernor : continuousGovernors) {
        continuousGovernor.display();
    }

private List continuousGovernors() {
return devices.values().stream()
.filter(d -> d instanceof ContinuousGovernor)
.map(d -> (ContinuousGovernor) d)
.collect(Collectors.toList());
}
private List incandescentLamps() {
return devices.values().stream()
.filter(d -> d instanceof IncandescentLamp)
.map(d -> (IncandescentLamp) d)
.collect(Collectors.toList());
}
使用 Map<String, CircuitDevice> devices = new LinkedHashMap<>();添加各种不同的电器，及题目中所涉及的电器都添加到此链表中去
使用 Map<String, CircuitDevice> mainDevices = new HashMap<>();因为题目中的主电路包含串联电路和并联电路，所以创建此链表保存，主电路中的电器，一个并联电路也视作为主电路中的一个电器元件。
使用 Map<String, SeriesCircuit> seriesCircuits = new HashMap<>();用来保存一个并联电路中的各个支路，方便对并联电路进行操作
使用 public void calculatePartialPressure()的方法，来计算各部分电器元件的电压。
使用 private boolean mianClosure()方法，来判断整个电路是否为通路。
（2)设计ParallelCircuit类继承自ControlledDevice类，此类为并联电路类，用来保存并联电路
部分源码：
class ParallelCircuit extends ControlledDevice{
private Map<String, SeriesCircuit> seriesCircuits = new HashMap<>();
private boolean isPathways = true;
public void setPathways() {
int flag = -1;
for(SeriesCircuit seriesCircuit : seriesCircuits.values()) {
if(seriesCircuit.isPathways()) {
//System.out.println("0000");
flag = 1;
break;
}
}
if(flag == -1) {
this.isPathways = false;
}else {
this.isPathways = true;
}
}

public void addSeriesCircuit(SeriesCircuit seriesCircuit) {
	seriesCircuits.put(seriesCircuit.getNumber(), seriesCircuit);
}
public void setParallelR() {
	double R = 0;
	for(SeriesCircuit seriesCircuit : seriesCircuits.values())  {
		if(seriesCircuit.isPathways() && seriesCircuit.getTotalR() == 0) {
			break;
		}else if(seriesCircuit.isPathways() && R == 0){
			
			R = seriesCircuit.getTotalR();
			//System.out.println(R);
		}else if (seriesCircuit.isPathways() && R != 0) {
			R = 1.0/(1.0/R +1.0/ seriesCircuit.getTotalR());
		}
		//System.out.println(R);
	}
	
        resistance = R;
}
public void setV() {
	for(SeriesCircuit seriesCircuit : seriesCircuits.values()) {
		if(seriesCircuit.isPathways()) {
			seriesCircuit.setVoltage(inputVoltage);				
		}
		else seriesCircuit.setVoltage(0);
		seriesCircuit.setV();
		//System.out.println(seriesCircuit.getVoltage());
	}
}

}
使用 Map<String, SeriesCircuit> seriesCircuits = new HashMap<>();用来保存并联电路中的每个支路。
使用 public void setPathways();方法，因为并联电路的支路可能含有开关，所以设计此方法来判断整个并联电路是否为通路。
使用 public void setParallelR();方法来计算整个并联电路的总电组，方便后续进行分压。
使用 public void setV();方法来给并联电路中的各个电器元件都设置相应的电压
（3）设计SeriesCircuit类继承自CircuitDevice类，此类为串联电路类，视作为并联电路中的每个支路
class SeriesCircuit extends CircuitDevice{
private Map<String, CircuitDevice> devices = new HashMap<>();
private boolean isPathways = true;
private double totalR = 0;
public void setPathways() {
List switchList = new LinkedList<>();
for(CircuitDevice circuitDevice : devices.values()) {
if(circuitDevice instanceof Switch) {
switchList.add((Switch) circuitDevice);
//Switch switchDevice = (Switch) circuitDevice;
//System.out.println(switchDevice.getNumber() + switchDevice.isClosure());
}
}
if(!switchList.isEmpty()) {
for (Switch switchItem : switchList) {
if(!switchItem.isClosure()) {
this.isPathways = false;
break;
}
}
}else {
this.isPathways = true;
}
}
public void setV() {
for(CircuitDevice circuitDevice : devices.values()) {
if(circuitDevice instanceof IncandescentLamp) {
((IncandescentLamp) circuitDevice).setInputVoltage(Voltage);
}else if(circuitDevice instanceof FluorescentLamp) {
((FluorescentLamp) circuitDevice).setInputVoltage(Voltage);
}else if(circuitDevice instanceof CeilingFan) {
((CeilingFan) circuitDevice).setInputVoltage(Voltage);
}else if(circuitDevice instanceof FloorFan) {
((FloorFan) circuitDevice).setInputVoltage(Voltage);
}
}
}
}
使用 Map<String, CircuitDevice> devices = new HashMap<>();用来保存每个支路中的电器元件。
使用 public void setPathways();来判断每个支路是否为通路。
（4）设计Main类，用于测试
部分源码：
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Circuit devices = new Circuit();
ParallelCircuit parallelDevice = new ParallelCircuit(null);
String str;
do{
str = input.nextLine();
if(str.startsWith("#T")) {
String number = str.substring(1,3);
String symbol = str.substring(4, 6);
if(symbol.equals("[I")) {
SeriesCircuit seriesCircuit = new SeriesCircuit(number);
Pattern pattern = Pattern.compile("\b[A-Z]\d+\b");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
if(matcher.group().startsWith("K")) {
Switch aSwitch = new Switch(matcher.group());
devices.addDevice(aSwitch);
seriesCircuit.addSeriesCircuits(aSwitch);
}else if(matcher.group().startsWith("B")) {
IncandescentLamp incandescentLamp = new IncandescentLamp(matcher.group());
devices.addDevice(incandescentLamp);
seriesCircuit.addSeriesCircuits(incandescentLamp);
}else if(matcher.group().startsWith("R")) {
FluorescentLamp fluorescentLamp = new FluorescentLamp(matcher.group());
devices.addDevice(fluorescentLamp);
seriesCircuit.addSeriesCircuits(fluorescentLamp);
}else if(matcher.group().startsWith("D")) {
CeilingFan ceilingFan = new CeilingFan(matcher.group());
devices.addDevice(ceilingFan);
seriesCircuit.addSeriesCircuits(ceilingFan);
}else if(matcher.group().startsWith("A")) {
FloorFan floorFan = new FloorFan(matcher.group());
devices.addDevice(floorFan);
seriesCircuit.addSeriesCircuits(floorFan);
}
}
seriesCircuit.setTotalR();
devices.addSeriesCircuit(seriesCircuit);
}else if(symbol.equals("[V")) {
Pattern pattern = Pattern.compile("\b[A-Z]\d+\b");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
if(matcher.group().startsWith("K")) {
Switch aSwitch = new Switch(matcher.group());
devices.addMainDevice(aSwitch);
devices.addDevice(aSwitch);
}else if(matcher.group().startsWith("M")) {
devices.addMainDevice(parallelDevice);
devices.addDevice(parallelDevice);
}else if(matcher.group().startsWith("B")) {
IncandescentLamp incandescentLamp = new IncandescentLamp(matcher.group());
devices.addMainDevice(incandescentLamp);
devices.addDevice(incandescentLamp);
}else if(matcher.group().startsWith("R")) {
FluorescentLamp fluorescentLamp = new FluorescentLamp(matcher.group());
devices.addMainDevice(fluorescentLamp);
devices.addDevice(fluorescentLamp);
}else if(matcher.group().startsWith("D")) {
CeilingFan ceilingFan = new CeilingFan(matcher.group());
devices.addMainDevice(ceilingFan);
devices.addDevice(ceilingFan);
}else if(matcher.group().startsWith("A")) {
FloorFan floorFan = new FloorFan(matcher.group());
devices.addMainDevice(floorFan);
devices.addDevice(floorFan);
}else if(matcher.group().startsWith("F")) {
BinningGovernor binningGovernor = new BinningGovernor(matcher.group());
devices.addMainDevice(binningGovernor);
devices.addDevice(binningGovernor);
devices.setVoltage(0);
}else if(matcher.group().startsWith("L")) {
ContinuousGovernor continuousGovernor = new ContinuousGovernor(matcher.group());
devices.addMainDevice(continuousGovernor);
devices.addDevice(continuousGovernor);
devices.setVoltage(0);
}
}
}
}else if(str.startsWith("#M")) {
String number = str.substring(1,3);
parallelDevice.setNumber(number);
Pattern pattern = Pattern.compile("T\d+");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
parallelDevice.addSeriesCircuit(devices.findSeriesCircuit(matcher.group()));
}
devices.addDevice(parallelDevice);
}else if(str.startsWith("#K") || str.startsWith("#L") || str.startsWith("#F")) {
devices.controlCommend(str);

		}									
	}while(!str.equals("end"));

}
首先判断是否以#T开头，是则加入串联电路类，然后就是#M开头，是则加入并联电路类，最后就是加入调控电路的方法。
（5）其余的类与上次大作业的基本相似。
3.踩坑心得
题目集4
由于本次实验的答题判断程序并未完成，所以没有啥踩坑和心得，这次实验基本处于放弃状态，由于前几次的程序并未完成，导致本次程序完成度低，在此深感抱歉。
题目集5
（1）Main类，开始用的str.substring方法并不能正常提取出识别电路的关键词,后来改为startwith方法识别关键词，使用while循环方法识别关键词有误，程序虽然没有报错，但是程序运行之后并没有输出，后来改成do,while循环，做出适当的调整，程序就有输出了
（2）一开始并没有设计电器类，只设置了受控设备类和控制设备类，各种不同的电器继承不同的基础设备类，导致代码繁琐，在实现一些方法上也有小问题，而且不方便存储所有的电器，只能分开存储不同的电器，所以设置电器类，受控设备类和控制设备类继承自电器类，其他各种电器继承这两种基础设备，这样在存储电器时就可以直接创建一个链表存储所有的电器，由此就可以方便同时对所有的电器进行操作，避免了过程过于繁琐，可以在电器类分别创建受控设备和控制设备的链表，方便对它们分别进行不同的操作
(3)实现电器状态输出顺序的方式，一开始电器输出的顺序有问题，因为题目所要求的顺序为按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。所以我给每个小受控设备都建立了链表，实现collectior,对他们进行要求的排序，最后在show方法中一次实现他们的输出.
题目集6
（1）Main类，方法调用的顺序会导致我的程序运行问题，在仔细思索后调整方法的调用顺序，并且要注意一个事项，在识别到分档调速器或者连续调速器时，要先设置整体电压为零，这样才能使整个电路的电压在没有受到调控器调控时电压为正常状态
（2）Circuit类，一开始无法正确设置并联电路中支路的开闭情况以及分压，所以增加一个Map链表，专门给并联电路的支路进行判断和调控，给上次的ControlCommend方法增加一个判断整个电路是否为通路的情况，如果不为通路，则设置整个电路电压为零，所有给所有设备识别开关时是否为闭合的状态的方法。在本次实验中，还要增加设置分压的方法，从而可以输出所有电器的状态，但要注意其中并联电路含有开关的情况，识别通过并联电路的通电情况才能对整个电路做出判断。
（3）并联电路类，要注意整个并联电路是否为通路状态，所以要是被每条支路的通断情况
（4）支路类，识别每个支路的通断情况，从而才能对整个并联电路进行通断识别
4.改进建议
（1）自己写的代码类之间的关系不是绝对的清晰，即不能很好的实现单一职责的功能。
（2）还有类中的方法，有些方法的使用有些错误，因为没给测试点，所以很多种情况并没有考虑到，所以会导致代码方法的问题。
（3）一些该考虑的情况没有被考虑到，所以会导致一些需要的方法被遗漏，或者方法使用的错误，类间关系的错误。
5.总结
通过这三次实验，对类之间关系的使用有了更清楚的认知，对继承，抽象方法使用的更加熟练，逻辑思维的提高，自我动手，自我思考能力增强，解决问题的能力增强
提一些建议，可以分小组一起讨论，从而让更多的同学有学习的动力

标签：String,Bolg,void,devices,else,new,第二次,public
From： https://www.cnblogs.com/nchuhz/p/18237219

相关文章

  • Java第二次Blog
    7-4~6题目集前言这些题目主要用到对象与类的处理继承与多态的使用：继承和多态是面向对象编程中相互关联的两个概念。继承为多态提供了基础，而多态则通过继承实现了代码的灵活性和可扩展性。1.字符串处理：需要对输入的题目信息和答题信息进行字符串分割、提取和处理，以获取题目编号......
  • 第二次Blog
    一.前言第四次大作业是第三次大作业的迭代，增加了题目的类型，即题目可以有选择题和填空题，其中选择题也可能有多选题，存在多个答案。以此增加了对继承和多态的使用，同时也考验了正则表达式的匹配，输入时的情况与第三次改变较大。接下来五到六次大作业则改变为对电路的设计，总体也是考察......
  • 南昌航空大学软件学院23201823第二次blog
    一、前言：这是第二次的blog，接下来关于这最近三次的PTA大作业，只有第一次是上次答题判题程序的延续，接下来则是一个全新的关于电路的设计，最新的电路设计相较于之前的答题判题程序来说的话，难度确实有所下降。前两次中都含有三道题，而最后一次的PTA则是删去了其余两道题，让我们专心钻研新......
  • 第二次Blog
    题目集4~6总结性Blog一、前言在题目集4至6的完成过程中，我深入学习了多个编程知识点，并在实践中不断巩固和提升。针对7-1题目，我发现这三次题目集在知识点的考察上具有一定的连贯性和递进性，题量适中，难度逐渐上升。7-1题目通常作为每个题目集的压轴题，不仅考查了我们对基础知识的掌握......
  • 第二次blog总结
    目录一.前言二.设计与分析：三.踩坑心得四．改进建议五．总结一.前言第四次大作业：1.题量：这次的大作业有三道题，题量较少。2.难度：第四次大作业的核心题目答题判题程序-4是经过了三次对第一次答题判题程序为基础的迭代而成，难度毋庸置疑，而且因为第一次总结，这次大作业距离上一次大作业也......
  • PTA三次题目集总结-第二次blog
    以下内容是我对pta题目集4-6次大作业的总结nchu-software-oop-2024-上-4本次作业新增内容：1、输入选择题题目信息题目信息为独行输入，一行为一道题，多道题可分多行输入。格式："#Z:"+题目编号+""+"#Q:"+题目内容+""#A:"+标准答案格式基本的约束与一般的题目输入信息一致。新......
  • 第二次Blog
    （1）前言：智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境......
  • 第二次Bolg
    (1)前言：这几次的大作业的包含了String类的使用和各种String的处理方法，包括字符串按照正则表达式查找和切割。以及很多新知识点，包括类的封装，继承和多态，其中继承可以说是贯穿整个程序，继承可以让程序简单易读，好修改，而这个还要求进行一个复杂性很高的排序，所以还用到了TreeMap集合进......
  • 第二次blog
    一.前言1.题目集4~6的知识点：（1）这几个题目都使用了面向对象编程原理，根据题目给出的信息和题目的复杂程度，建立了对应的类，并在类中添加了方法。通过使用Java自带的类库，如Scanner类中的方法用于接收用户输入，regex.Matcher类中的方法用于正则表达式匹配，regex.Pattern类中的方法用于编......
  • 第二次blog总结
    一、前言：第四次pta作业：1.知识点：考察类的继承，抽象类的使用。2.题量：3道简单题，1道迭代难题。3.难度：这次最后一道题在上次的基础上添加了题目的种类（eg:选择题、填空题）等，难度增加的还行，不算太难也不算太容易。第五次pta作业：1.知识点：考察类实现Comparable接口，重写compareTo......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99