课程阶段性总结

前言:

学习Java到了第二个阶段了,通过这几个月的学习,我对Java的了解逐渐深入.但是随着深入学习,我发现编写代码所需要的知识越来越多,就需要我们不断学习更多的知识.通过这几次的大作业,让我成长的非常迅速,为我提供了宝贵的实践机会。我将对题目集的知识点、题量及难度进行简要总结。

一.知识点

1.抽象类和方法 2.封装 3.多态 4.接口

二.题量

题量相较于前几次是非常少的.量少,但是非常经典.

三.难度

难度是非常大的,一次大作业每每需要五六天时间来完成,虽然难但是所涉及到的知识点非常广泛,学习到的东西非常多.

设计与分析:

代码:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 电路设备基类
abstract class CircuitDevice {
protected int id;
protected int inputPin;
protected int outputPin;

public CircuitDevice(int id, int inputPin, int outputPin) {
this.id = id;
this.inputPin = inputPin;
this.outputPin = outputPin;
}

public abstract double getOutputVoltage(double inputVoltage);
}

// 控制设备类
class ControlDevice extends CircuitDevice {
public ControlDevice(int id, int inputPin, int outputPin) {
super(id, inputPin, outputPin);
}
}

// 开关类
class Switch extends ControlDevice {
private int state; // 0表示打开,1表示关闭

public Switch(int id) {
super(id, 1, 2);
this.state = 0;
}

public void toggleState() {
this.state = 1 - this.state;
}

@Override
public double getOutputVoltage(double inputVoltage) {
return this.state == 0 ? inputVoltage : 0;
}
}

// 分档调速器类
class StepDimmer extends ControlDevice {
private int level; // 0-3表示4个档位

public StepDimmer(int id) {
super(id, 1, 2);
this.level = 0;
}

public void increaseLevel() {
this.level = Math.min(this.level + 1, 3);
}

public void decreaseLevel() {
this.level = Math.max(this.level - 1, 0);
}

@Override
public double getOutputVoltage(double inputVoltage) {
return inputVoltage * (this.level * 0.3);
}
}

// 连续调速器类
class ContinuousDimmer extends ControlDevice {
private double level; // 0.00-1.00

public ContinuousDimmer(int id) {
super(id, 1, 2);
this.level = 0.0;
}

public void setLevel(double level) {
this.level = Math.max(0.0, Math.min(1.0, level));
}

@Override
public double getOutputVoltage(double inputVoltage) {
return inputVoltage * this.level;
}
}

// 受控设备类
class ControlledDevice extends CircuitDevice {
public ControlledDevice(int id, int inputPin, int outputPin) {
super(id, inputPin, outputPin);
}

public abstract double getOutputParameter(double inputVoltage);
}

// 白炽灯类
class IncandescentLight extends ControlledDevice {
private double brightness; // 0-200 lux

public IncandescentLight(int id) {
super(id, 1, 2);
this.brightness = 0;
}

@Override
public double getOutputParameter(double inputVoltage) {
if (inputVoltage >= 0 && inputVoltage < 9) {
this.brightness = 0;
} else if (inputVoltage >= 10 && inputVoltage <= 220) {
this.brightness = (inputVoltage - 10) / 210.0 * 200;
} else {
this.brightness = 200;
}
return Math.floor(this.brightness);
}
}

// 日光灯类
class FluorescentLight extends ControlledDevice {
private double brightness; // 0 or 180 lux

public FluorescentLight(int id) {
super(id, 1, 2);
this.brightness = 0;
}

@Override
public double getOutputParameter(double inputVoltage) {
this.brightness = inputVoltage == 0 ? 0 : 180;
return this.brightness;
}
}

// 吊扇类
class CeilingFan extends ControlledDevice {
private double speed; // 80-360 rpm

public CeilingFan(int id) {
super(id, 1, 2);
this.speed = 0;
}

@Override
public double getOutputParameter(double inputVoltage) {
if (inputVoltage >= 80 && inputVoltage <= 150) {
this.speed = (inputVoltage - 80) / 70.0 * 280 + 80;
} else if (inputVoltage > 150) {
this.speed = 360;
} else {
this.speed = 0;
}
return Math.floor(this.speed);
}
}

// 电路连接类
class CircuitConnection {
private List<CircuitDevice> devices;
private double voltage;

public CircuitConnection() {
this.devices = new ArrayList<>();
this.voltage = 220.0;
}

public void addDevice(CircuitDevice device) {
this.devices.add(device);
}

public void processInput(String input) {
if (input.startsWith("#")) {
processCommand(input);
} else if (input.startsWith("[")) {
processConnection(input);
} else if (input.equals("end")) {
return;
} else {
System.out.println("Invalid input: " + input);
}
}

private void processCommand(String command) {
if (command.startsWith("#K")) {
int id = Integer.parseInt(command.substring(2));
for (CircuitDevice device : this.devices) {
if (device instanceof Switch && device.id == id) {
((Switch) device).toggleState();
break;
}
}
} else if (command.startsWith("#F")) {
int id = Integer.parseInt(command.substring(2, 3));
if (command.endsWith("+")) {
for (CircuitDevice device : this.devices) {
if (device instanceof StepDimmer && device.id == id) {
((StepDimmer) device).increaseLevel();
break;
}
}
} else if (command.endsWith("-")) {
for (CircuitDevice device : this.devices) {
if (device instanceof StepDimmer && device.id == id) {
((StepDimmer) device).decreaseLevel();
break;
}
}
}
} else if (command.startsWith("#L")) {
int id = Integer.parseInt(command.substring(2, 3));
double level = Double.parseDouble(command.substring(4));
for (CircuitDevice device : this.devices) {
if (device instanceof ContinuousDimmer && device.id == id) {
((ContinuousDimmer) device).setLevel(level);
break;
}
}
}
}

private void processConnection(String connection) {
String[] pins = connection.substring(1, connection.length() - 1).split(" ");
CircuitDevice prevDevice = null;
double prevOutputVoltage = this.voltage;

for (String pin : pins) {
String[] parts = pin.split("-");
int deviceId = Integer.parseInt(parts[0].substring(1));
int pinId = Integer.parseInt(parts[1]);

CircuitDevice device = null;
for (CircuitDevice d : this.devices) {
if (d.id == deviceId) {
device = d;
break;
}
}

if (device == null) {
if (parts[0].startsWith("V")) {
prevOutputVoltage = this.voltage;
} else if (parts[0].startsWith("G")) {
prevOutputVoltage = 0;
} else {
System.out.println("Invalid device: " + parts[0]);
return;
}
} else {
if (pinId == device.inputPin) {
device.getOutputVoltage(prevOutputVoltage);
} else if (pinId == device.outputPin) {
if (prevDevice != null) {
prevOutputVoltage = prevDevice.getOutputVoltage(prevOutputVoltage);
}
} else {
System.out.println("Invalid pin: " + pin);
return;
}

if (prevDevice != null) {
prevDevice.getOutputVoltage(prevOutputVoltage);
}
prevDevice = device;
}
}
}

public void printStatus() {
for (CircuitDevice device : this.devices) {
if (device instanceof Switch) {
System.out.printf("@K%d:%s%n", device.id, ((Switch) device).state == 0 ? "turned on" : "closed");
} else if (device instanceof StepDimmer) {
System.out.printf("@F%d:%d%n", device.id, ((StepDimmer) device).level);
} else if (device instanceof ContinuousDimmer) {
System.out.printf("@L%d:%.2f%n", device.id, ((ContinuousDimmer) device).level);
} else if (device instanceof IncandescentLight) {
System.out.printf("@B%d:%.0f%n", device.id, ((IncandescentLight) device).getOutputParameter(device.getOutputVoltage(this.voltage)));
} else if (device instanceof FluorescentLight) {
System.out.printf("@R%d:%.0f%n", device.id, ((FluorescentLight) device).getOutputParameter(device.getOutputVoltage(this.voltage)));
} else if (device instanceof CeilingFan) {
System.out.printf("@D%d:%.0f%n", device.id, ((CeilingFan) device).getOutputParameter(device.getOutputVoltage(this.voltage)));
}
}
}
}

public class SmartHomeSimulator {
public static void main(String[] args) {
CircuitConnection circuit = new CircuitConnection();
Scanner scanner = new Scanner(System.in);

while (true) {
String input = scanner.nextLine();
circuit.processInput(input);
if (input.equals("end")) {
break;
}
}

circuit.printStatus();
}
}

 devices：存储所有电路设备的列表。voltage：电路的输入电压，默认为220.0V。addDevice(CircuitDevice device)：向电路中添加设备。processInput(String input)：处理输入的命令或连接信息。processCommand(String command)：处理命令。processConnection(String connection)：处理设备之间的连接。printStatus()：打印所有设备的状态。

 main方法中创建了一个CircuitConnection实例和一个Scanner实例，用于读取用户输入。在一个循环中读取输入，直到输入为"end"时退出循环。调用processInput方法处理输入，然后调用printStatus方法打印所有设备的状态。这个模拟器的目的是模拟智能家居中的电路设备，包括开关、调速器和各种电器，以及它们之间的连接和交互。用户可以通过输入特定的命令来控制这些设备，模拟器会根据这些命令更新设备的状态并输出结果。

继承自ControlDevice。state：表示开关的状态，0为打开，1为关闭。toggleState()：切换开关状态。getOutputVoltage(double inputVoltage)：如果开关打开，输出电压等于输入电压；如果关闭，输出电压为0。

踩坑心得:

PTA发布都会是在之前的基础上迭代的，会越来越难，这就导致我如果继续按照这样的写法就会很麻烦因为几乎每一道题都需要重新思考,最开始的正则表达式无法匹配，一直报错，最终对正则表达式进行修改才将正确有效信息录入,在代码测试和调试方面存在一定的不足。没有考虑到边界条件，导致函数在某些情况下无法正确运行.

改进建议:

针对一些涉及复杂计算或大量数据处理的题目，可以尝试使用更高效的算法和数据结构来提高程序的性能。提前开始最后一题的思考，有什么问题一定要和同学一起讨论.在编码过程中，应注重代码的规范性和可读性

总结:

基类定义：
CircuitDevice：电路设备的基类，定义了所有电路设备共有的属性（id、inputPin、outputPin）和方法（getOutputVoltage）。
ControlDevice：控制设备的基类，继承自CircuitDevice。
ControlledDevice：受控设备的基类，也继承自CircuitDevice。
具体类实现：
Switch：表示一个开关，具有打开和关闭的状态。
StepDimmer：分档调速器，可以设置不同的档位。
ContinuousDimmer：连续调速器，可以调节电压的连续变化。
IncandescentLight：白炽灯，亮度与输入电压相关。
FluorescentLight：日光灯，亮度固定为180 lux。
CeilingFan：吊扇，速度与输入电压相关。
电路连接管理：
CircuitConnection：负责管理所有电路设备的连接，包括添加设备、处理输入和输出。
addDevice(CircuitDevice device)：向电路中添加新的设备。
processInput(String input)：处理用户的输入命令，如开关状态、调速器档位等。
processConnection(String connection)：处理设备之间的连接信息。
printStatus()：打印所有设备的状态信息。
用户交互：
main 方法中创建了一个CircuitConnection实例和一个Scanner实例，用于读取用户输入。
在一个循环中读取用户输入，直到输入为"end"时退出循环。
调用processInput方法处理输入，然后调用printStatus方法打印所有设备的状态。
异常处理：
代码中包含了对输入字符串的处理，如解析命令和连接信息，以及可能的异常处理。
功能扩展：
代码提供了基础的设备管理和状态打印功能，可以在此基础上进一步扩展，例如添加更多类型的设备、实现更复杂的控制逻辑、添加用户界面等。
这个模拟器框架为智能家居系统的设计和实现提供了一个良好的起点，可以根据具体需求进行扩展和优化。