电梯调度系统代码分析与总结（blog版）
一、 前言
我勒个豆，三个电梯搞得我头都炸了，硬着头皮熬夜干完的
二、设计与分析
（一）第一个代码
点击查看代码
import java.util.*;
class Request {
private int floor;
public Request(int floor) {
this.floor = floor;
}
public int getFloor() {
return floor;
}
}
class InsideRequest extends Request {
public InsideRequest(int floor) {
super(floor);
}
}
class OutsideRequest extends Request {
private String direction;
public OutsideRequest(int floor, String direction) {
super(floor);
this.direction = direction;
}
public String getDirection() {
return direction;
}
}
class Elevator {
private int minFloor;
private int maxFloor;
private int currentFloor;
private String direction;
private String state;
private List<Request> insideRequests;
private List<Request> outsideRequests;
public Elevator(int minFloor, int maxFloor) {
this.minFloor = minFloor;
this.maxFloor = maxFloor;
this.currentFloor = minFloor;
this.direction = "UP";
this.insideRequests = new ArrayList<>();
this.outsideRequests = new ArrayList<>();
}
public void addRequest (Request request) {
if (request instanceof InsideRequest) {
insideRequests.add (request);
} else if (request instanceof OutsideRequest) {
outsideRequests.add (request);
}
}
public void run(){
System.out.println("Current Floor: " + "1" + " Direction: " + "UP" );
currentFloor = 1;
while (true) {
if(outsideRequests.isEmpty() && insideRequests.isEmpty()){
break;
}
while (!outsideRequests.isEmpty() || !insideRequests.isEmpty()) {
int value = 0;
if (outsideRequests.isEmpty() && !insideRequests.isEmpty()) {
value = 2;
} else if (!outsideRequests.isEmpty() && insideRequests.isEmpty()) {
value = 1;
} else if (!outsideRequests.isEmpty() && !insideRequests.isEmpty()) {
value = 3;
}
switch (value) {
case 1:
OutsideRequest outsideRequest = (OutsideRequest) outsideRequests.get(0);
String requestDirection = outsideRequest.getDirection();//向下转型
if (requestDirection.equals("UP") && requestDirection.equals(direction)) {
if (currentFloor < outsideRequests.get(0).getFloor()) {
currentFloor++;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
if (currentFloor > outsideRequests.get(0).getFloor())
{
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
}
else {
if (currentFloor > outsideRequests.get(0).getFloor()) {
currentFloor--;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
if (currentFloor < outsideRequests.get(0).getFloor()) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
}
if (currentFloor == outsideRequests.get(0).getFloor()) {
openDoor(currentFloor);
closeDoor();
outsideRequests.remove(0);
break;
}
break;
case 2:
if (currentFloor > insideRequests.get(0).getFloor()) {
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
if (currentFloor < insideRequests.get(0).getFloor()) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
break;
}
if (currentFloor == insideRequests.get(0).getFloor()) {
openDoor(currentFloor);
closeDoor();
insideRequests.remove(0);
break;
}
break;
case 3:
OutsideRequest outsideRequesta = (OutsideRequest) outsideRequests.get(0);
String requestDirectiona = outsideRequesta.getDirection();
if ( requestDirectiona.equals(direction)) {
if(direction.equals("UP"))
{
hasUpRequest();
}
else {
hasDownRequest();
}
}else
{
if(direction.equals("DOWN"))
{elsehasdownRequest();
}
else {
elsehasupRequest();
}
}
if(currentFloor == outsideRequests.get(0).getFloor() && currentFloor == insideRequests.get(0).getFloor())
{
openDoor(currentFloor);
closeDoor();
outsideRequests.remove(0);
insideRequests.remove(0);
break;
}
if (direction.equals(((OutsideRequest) outsideRequests.get(0)).getDirection()) && currentFloor == outsideRequests.get(0).getFloor()) {
openDoor(currentFloor);
closeDoor();
outsideRequests.remove(0);
break;
}
if (currentFloor == insideRequests.get(0).getFloor()) {
openDoor(currentFloor);
closeDoor();
insideRequests.remove(0);
break;
}
break;
}
}
}
}
public void elsehasdownRequest()
{
if (currentFloor > outsideRequests.get(0).getFloor() || insideRequests.get(0).getFloor() < currentFloor) {
currentFloor--;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if(currentFloor < outsideRequests.get(0).getFloor() && currentFloor < insideRequests.get(0).getFloor()) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if(currentFloor == outsideRequests.get(0).getFloor() && currentFloor < insideRequests.get(0).getFloor())
{
direction = "UP";
}
}
public void elsehasupRequest()
{
if (currentFloor < outsideRequests.get(0).getFloor() || insideRequests.get(0).getFloor() > currentFloor) {
currentFloor++;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if(currentFloor > outsideRequests.get(0).getFloor() && currentFloor > insideRequests.get(0).getFloor()) {
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if(currentFloor == outsideRequests.get(0).getFloor() && currentFloor > insideRequests.get(0).getFloor())
{
direction = "DOWN";
}
}
public void hasUpRequest()
{
if (currentFloor < outsideRequests.get(0).getFloor() || insideRequests.get(0).getFloor() > currentFloor) {
currentFloor++;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor > outsideRequests.get(0).getFloor() && insideRequests.get(0).getFloor() < currentFloor) {
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
}
public void hasDownRequest()
{
if (currentFloor > outsideRequests.get(0).getFloor() || insideRequests.get(0).getFloor() < currentFloor) {
currentFloor--;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor < outsideRequests.get(0).getFloor() && insideRequests.get(0).getFloor() > currentFloor) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
}
private void openDoor (int floor) {
System.out.println ("Open Door # Floor " + floor);
}
private void closeDoor () {
System.out.println ("Close Door");
}
}
public class Main {
public static void main (String [] args) {
Scanner scanner = new Scanner (System.in);
int minFloor = scanner.nextInt ();
int maxFloor = scanner.nextInt ();
scanner.nextLine ();
Elevator elevator = new Elevator (minFloor, maxFloor);
while (true) {
String input = scanner.nextLine().trim();
if ("end".equalsIgnoreCase(input)) {
break;
}
if (input.startsWith("<") && input.endsWith(">")) {
input = input.substring(1, input.length() - 1);
if (input.contains(",")) {
String[] parts = input.split(",");
int floor = Integer.parseInt(parts[0]);
String direction = parts[1];
elevator.addRequest(new OutsideRequest(floor, direction));
} else {
int floor = Integer.parseInt(input);
elevator.addRequest(new InsideRequest(floor));
}
}
}
elevator.run();
}
}
参数分析： 
- 功能实现：在功能实现方面，代码实现了电梯的基本运行逻辑。通过addRequest方法将不同类型的请求添加到相应队列，run方法根据请求队列的情况控制电梯运行。在处理请求时，通过复杂的switch语句和多层if - else判断，依据电梯当前楼层、请求楼层和方向来决定电梯的运行方向和停靠楼层。虽然基本功能得以实现，但这种实现方式存在大量重复判断逻辑，例如在处理外部请求时，对于不同方向和楼层关系的判断多次出现，使得代码冗长且难以理解。此外，代码没有处理无效请求，如输入的楼层超过电梯的最大或最小楼层时，程序可能会出现异常行为。
- 代码质量：从代码质量角度来看，缺乏必要的输入校验机制。用户输入的楼层和方向没有进行合法性检查，这可能导致程序在运行时因非法输入而崩溃或产生错误结果。并且，代码中没有考虑异常处理，如当请求队列为空时进行移除操作可能会抛出异常，这会影响程序的稳定性和健壮性。同时，代码的注释较少，对于复杂的逻辑部分没有清晰的解释，不利于他人阅读和维护。
（二）第二个代码
点击查看代码
import java.util.*;
class Request {
private int floor;
public Request(int floor) {
this.floor = floor;
}
public int getFloor() {
return floor;
}
}
class InsideRequest extends Request {
public InsideRequest(int floor) {
super(floor);
}
}
class OutsideRequest extends Request {
private String direction;
public OutsideRequest(int floor, String direction) {
super(floor);
this.direction = direction;
}
public String getDirection() {
return direction;
}
}
class Elevator {
private int minFloor;
private int maxFloor;
private int currentFloor;
private String direction;
private String state;
private List<Request> insideRequests;
private List<Request> outsideRequests;
public Elevator(int minFloor, int maxFloor) {
this.minFloor = minFloor;
this.maxFloor = maxFloor;
this.currentFloor = minFloor;
this.direction = "UP";
this.insideRequests = new ArrayList<>();
this.outsideRequests = new ArrayList<>();
}
public void addRequest(Request request) {
if (request instanceof InsideRequest) {
insideRequests.add(request);
} else if (request instanceof OutsideRequest) {
outsideRequests.add(request);
}
}
public int getCurrentFloor() {
return currentFloor;
}
public String getDirection() {
return direction;
}
public List<Request> getInsideRequests() {
return insideRequests;
}
public List<Request> getOutsideRequests() {
return outsideRequests;
}
public void setCurrentFloor(int currentFloor) {
this.currentFloor = currentFloor;
}
public void setDirection(String direction) {
this.direction = direction;
}
public void openDoor(int floor) {
System.out.println("Open Door # Floor " + floor);
}
public void closeDoor() {
System.out.println("Close Door");
}
public void removeDuplicateRequests() {
// 处理 outsideRequests 中的连续重复请求
for (int i = 0; i < outsideRequests.size() - 1; i++) {
if (outsideRequests.get(i) instanceof OutsideRequest && outsideRequests.get(i + 1) instanceof OutsideRequest) {
OutsideRequest req1 = (OutsideRequest) outsideRequests.get(i);
OutsideRequest req2 = (OutsideRequest) outsideRequests.get(i + 1);
if (req1.getFloor() == req2.getFloor() && req1.getDirection().equals(req2.getDirection())) {
outsideRequests.remove(i);
i--; // 移除元素后，索引回退避免遗漏检查
}
}
}
// 处理 insideRequests 中的连续重复请求
for (int i = 0; i < insideRequests.size() - 1; i++) {
if (insideRequests.get(i).getFloor() == insideRequests.get(i + 1).getFloor()) {
insideRequests.remove(i);
i--; // 移除元素后，索引回退避免遗漏检查
}
}
}
public void elsehasdownRequest() {
if (!getOutsideRequests().isEmpty() && !getInsideRequests().isEmpty()) {
if (currentFloor > getOutsideRequests().get(0).getFloor() || getInsideRequests().get(0).getFloor() < currentFloor) {
currentFloor--;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor < getOutsideRequests().get(0).getFloor() && currentFloor < getInsideRequests().get(0).getFloor()) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor == getOutsideRequests().get(0).getFloor() && currentFloor < getInsideRequests().get(0).getFloor()) {
direction = "UP";
}
}
}
public void elsehasupRequest() {
if (!getOutsideRequests().isEmpty() && !getInsideRequests().isEmpty()) {
if (currentFloor < getOutsideRequests().get(0).getFloor() || getInsideRequests().get(0).getFloor() > currentFloor) {
currentFloor++;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor > getOutsideRequests().get(0).getFloor() && currentFloor > getInsideRequests().get(0).getFloor()) {
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor == getOutsideRequests().get(0).getFloor() && currentFloor > getInsideRequests().get(0).getFloor()) {
direction = "DOWN";
}
}
}
public void hasUpRequest() {
if (!getOutsideRequests().isEmpty() && !getInsideRequests().isEmpty()) {
if (currentFloor < getOutsideRequests().get(0).getFloor() || getInsideRequests().get(0).getFloor() > currentFloor) {
currentFloor++;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor > getOutsideRequests().get(0).getFloor() && getInsideRequests().get(0).getFloor() < currentFloor) {
currentFloor--;
direction = "DOWN";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
}
}
public void hasDownRequest() {
if (!getOutsideRequests().isEmpty() && !getInsideRequests().isEmpty()) {
if (currentFloor > getOutsideRequests().get(0).getFloor() || getInsideRequests().get(0).getFloor() < currentFloor) {
currentFloor--;
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
if (currentFloor < getOutsideRequests().get(0).getFloor() && getInsideRequests().get(0).getFloor() > currentFloor) {
currentFloor++;
direction = "UP";
System.out.println("Current Floor: " + currentFloor + " Direction: " + direction);
}
}
}
}
class ElevatorController {
private Elevator elevator;
public ElevatorController(Elevator elevator) {
this.elevator = elevator;
}
public void execute() {
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
while (true) {
if (elevator.getOutsideRequests().isEmpty() && elevator.getInsideRequests().isEmpty()) {
break;
}
elevator.removeDuplicateRequests();
handleRequests();
}
}
private void handleRequests() {
Elevator elevator = this.elevator;
while (!elevator.getOutsideRequests().isEmpty() || !elevator.getInsideRequests().isEmpty()) {
int value = 0;
if (elevator.getOutsideRequests().isEmpty() && !elevator.getInsideRequests().isEmpty()) {
value = 2;
} else if (!elevator.getOutsideRequests().isEmpty() && elevator.getInsideRequests().isEmpty()) {
value = 1;
} else if (!elevator.getOutsideRequests().isEmpty() && !elevator.getInsideRequests().isEmpty()) {
value = 3;
}
String requestDirection = null;
if (!elevator.getOutsideRequests().isEmpty()) {
OutsideRequest outsideRequest = (OutsideRequest) elevator.getOutsideRequests().get(0);
requestDirection = outsideRequest.getDirection();
}
switch (value) {
case 1:
if (requestDirection != null && requestDirection.equals("UP") && requestDirection.equals(elevator.getDirection())) {
if (elevator.getCurrentFloor() < elevator.getOutsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() + 1);
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else if (elevator.getCurrentFloor() > elevator.getOutsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() - 1);
elevator.setDirection("DOWN");
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
} else if (requestDirection != null) {
if (elevator.getCurrentFloor() > elevator.getOutsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() - 1);
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else if (elevator.getCurrentFloor() < elevator.getOutsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() + 1);
elevator.setDirection("UP");
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
}
if (!elevator.getOutsideRequests().isEmpty() && elevator.getCurrentFloor() == elevator.getOutsideRequests().get(0).getFloor()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.getOutsideRequests().remove(0);
}
break;
case 2:
if (!elevator.getInsideRequests().isEmpty()) {
if (elevator.getCurrentFloor() > elevator.getInsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() - 1);
elevator.setDirection("DOWN");
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else if (elevator.getCurrentFloor() < elevator.getInsideRequests().get(0).getFloor()) {
elevator.setCurrentFloor(elevator.getCurrentFloor() + 1);
elevator.setDirection("UP");
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
if (elevator.getCurrentFloor() == elevator.getInsideRequests().get(0).getFloor()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.getInsideRequests().remove(0);
}
}
break;
case 3:
if (requestDirection != null && requestDirection.equals(elevator.getDirection())) {
if (elevator.getDirection().equals("UP")) {
elevator.hasUpRequest();
} else {
elevator.hasDownRequest();
}
} else if (requestDirection != null) {
if (elevator.getDirection().equals("DOWN")) {
elevator.elsehasdownRequest();
} else {
elevator.elsehasupRequest();
}
}
if (!elevator.getOutsideRequests().isEmpty() && !elevator.getInsideRequests().isEmpty() && elevator.getCurrentFloor() == elevator.getOutsideRequests().get(0).getFloor() && elevator.getCurrentFloor() == elevator.getInsideRequests().get(0).getFloor()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.getOutsideRequests().remove(0);
elevator.getInsideRequests().remove(0);
} else if (!elevator.getOutsideRequests().isEmpty() && elevator.getDirection().equals(((OutsideRequest) elevator.getOutsideRequests().get(0)).getDirection()) && elevator.getCurrentFloor() == elevator.getOutsideRequests().get(0).getFloor()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.getOutsideRequests().remove(0);
} else if (!elevator.getInsideRequests().isEmpty() && elevator.getCurrentFloor() == elevator.getInsideRequests().get(0).getFloor()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.getInsideRequests().remove(0);
}
break;
}
}
}
}
public class Main {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
int minFloor = scanner.nextInt();
int maxFloor = scanner.nextInt();
scanner.nextLine();
Elevator elevator = new Elevator(minFloor, maxFloor);
while (true) {
String input = scanner.nextLine().trim();
if ("end".equalsIgnoreCase(input)) {
break;
}
if (input.startsWith("<") && input.endsWith(">")) {
input = input.substring(1, input.length() - 1);
if (input.contains(",")) {
String[] parts = input.split(",");
int floor = Integer.parseInt(parts[0]);
String direction = parts[1];
if (floor >= minFloor && floor <= maxFloor) {
elevator.addRequest(new OutsideRequest(floor, direction));
}
} else {
int floor = Integer.parseInt(input);
if (floor >= minFloor && floor <= maxFloor) {
elevator.addRequest(new InsideRequest(floor));
}
}
}
}
ElevatorController controller = new ElevatorController(elevator);
controller.execute();
}
}
}
代码分析：
- 功能实现：该代码在功能上不仅实现了电梯的基本运行功能，还增加了对连续重复请求的处理。removeDuplicateRequests方法通过遍历请求列表，比较相邻请求的楼层和方向，移除重复请求，提高了请求处理的效率和准确性。在电梯运行逻辑方面，ElevatorController类的execute和handleRequests方法通过对请求队列的判断和处理，控制电梯的运行方向和停靠楼层。虽然整体逻辑相对清晰，但switch语句和复杂的条件判断仍然存在，使得代码的可读性和维护性有待提高。此外，在处理请求时，对于一些边界情况的考虑还不够周全，例如当请求队列中只剩下一个请求时的处理逻辑。
- 代码质量：相较于第一个代码，第二个代码增加了输入校验，对输入的楼层进行范围检查，确保输入的楼层在电梯的有效范围内，这在一定程度上提高了程序的健壮性。然而，代码整体的复杂度仍然较高，部分方法的命名不够直观，如elsehasdownRequest和elsehasupRequest，从方法名难以直接理解其具体功能，这会增加代码阅读和维护的难度。同时，代码中的注释仍然较少，对于关键逻辑部分的解释不足，不利于代码的理解和维护。
（三）第三个代码
点击查看代码
import java.util.Scanner;
// 乘客类
class Passenger {
private int sourceFloor;
private int destinationFloor;
private String direction;
public Passenger(int sourceFloor, int destinationFloor) {
this.sourceFloor = sourceFloor;
this.destinationFloor = destinationFloor;
this.direction = sourceFloor < destinationFloor ? "UP" : "DOWN";
}
public int getSourceFloor() {
return sourceFloor;
}
public int getDestinationFloor() {
return destinationFloor;
}
public String getDirection() {
return direction;
}
}
// 队列类
class Queue<T> {
private java.util.ArrayList<T> items;
public Queue() {
this.items = new java.util.ArrayList<>();
}
public boolean isEmpty() {
return items.isEmpty();
}
public void enqueue(T item) {
items.add(item);
}
public T dequeue() {
if (isEmpty()) {
return null;
}
return items.remove(0);
}
public T getHead() {
if (isEmpty()) {
return null;
}
return items.get(0);
}
}
// 电梯类
class Elevator {
private int minFloor;
private int maxFloor;
public int currentFloor;
public String direction;
public Queue<Passenger> externalQueue;
public Queue<Integer> internalQueue;
public Elevator(int minFloor, int maxFloor) {
this.minFloor = minFloor;
this.maxFloor = maxFloor;
this.currentFloor = minFloor;
this.direction = "UP";
this.externalQueue = new Queue<>();
this.internalQueue = new Queue<>();
}
public void addExternalRequest(Passenger passenger) {
externalQueue.enqueue(passenger);
}
public void addInternalRequest(int floor) {
internalQueue.enqueue(floor);
}
public int getMaxFloor() {
return maxFloor;
}
public int getMinFloor() {
return minFloor;
}
public void openDoor(int floor) {
System.out.println("Open Door # Floor " + floor);
}
public void closeDoor() {
System.out.println("Close Door");
}
public int getCurrentFloor() {
return currentFloor;
}
public String getDirection() {
return direction;
}
public Queue<Passenger> getExternalQueue() {
return externalQueue;
}
public Queue<Integer> getInternalQueue() {
return internalQueue;
}
public void changeDirection() {
this.direction = this.direction.equals("UP") ? "DOWN" : "UP";
}
}
// 控制类
class ElevatorController {
private Elevator elevator;
public ElevatorController(Elevator elevator) {
this.elevator = elevator;
}
private boolean isValidFloor(int floor) {
return floor >= elevator.getMinFloor() && floor <= elevator.getMaxFloor();
}
public void processInput(String input) {
if (input.startsWith("<") && input.endsWith(">")) {
input = input.substring(1, input.length() - 1);
if (input.contains(",")) {
String[] parts = input.split(",");
int sourceFloor = Integer.parseInt(parts[0]);
int destinationFloor = Integer.parseInt(parts[1]);
if (isValidFloor(sourceFloor) && isValidFloor(destinationFloor)) {
Passenger passenger = new Passenger(sourceFloor, destinationFloor);
elevator.addExternalRequest(passenger);
}
} else {
int floor = Integer.parseInt(input);
if (isValidFloor(floor)) {
elevator.addInternalRequest(floor);
}
}
}
}
public void execute() {
while (true) {
if (elevator.externalQueue.isEmpty() && elevator.internalQueue.isEmpty()) {
break;
}
int count = 1;
int value = 0;
if (!elevator.internalQueue.isEmpty() && elevator.externalQueue.isEmpty()) {
value = 1; // 只有内部请求
} else if (elevator.internalQueue.isEmpty() && !elevator.externalQueue.isEmpty()) {
value = 2; // 只有外部请求
} else {
value = 3; // 两者都有
}
if(elevator.currentFloor == 1&&count==1){
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
count++;
}
switch (value) {
case 1:
if (elevator.getCurrentFloor() == elevator.internalQueue.getHead()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.internalQueue.dequeue();
} else if (elevator.currentFloor > elevator.internalQueue.getHead()) {
elevator.direction = "DOWN";
elevator.currentFloor--;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else {
elevator.direction = "UP";
elevator.currentFloor++;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
break;
case 2:
if (elevator.externalQueue.getHead().getSourceFloor() == elevator.currentFloor) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.addInternalRequest(elevator.externalQueue.getHead().getDestinationFloor());
elevator.externalQueue.dequeue();
} else if (elevator.getCurrentFloor() < elevator.externalQueue.getHead().getSourceFloor()) {
elevator.direction = "UP";
elevator.currentFloor++;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else {
elevator.direction = "DOWN";
elevator.currentFloor--;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
break;
case 3:
if (elevator.currentFloor == elevator.externalQueue.getHead().getSourceFloor() && elevator.currentFloor == elevator.internalQueue.getHead()&&elevator.externalQueue.getHead().getDirection().equals(elevator.direction)) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.addInternalRequest(elevator.externalQueue.getHead().getDestinationFloor());
elevator.externalQueue.dequeue();
elevator.internalQueue.dequeue();
} else if (elevator.currentFloor == elevator.externalQueue.getHead().getSourceFloor()&&elevator.externalQueue.getHead().getDirection().equals(elevator.direction)) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.addInternalRequest(elevator.externalQueue.getHead().getDestinationFloor());
elevator.externalQueue.dequeue();
} else if (elevator.currentFloor == elevator.internalQueue.getHead()) {
elevator.openDoor(elevator.getCurrentFloor());
elevator.closeDoor();
elevator.internalQueue.dequeue();
} else if (elevator.direction.equals("UP")) {
if (elevator.externalQueue.getHead().getSourceFloor() > elevator.currentFloor && elevator.externalQueue.getHead().getDirection().equals(elevator.direction)) {
elevator.currentFloor++;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else if (elevator.internalQueue.getHead() > elevator.currentFloor) {
elevator.currentFloor++;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else {
elevator.direction = "DOWN";
elevator.currentFloor--;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
} else if (elevator.direction.equals("DOWN")) {
if (elevator.externalQueue.getHead().getSourceFloor() < elevator.currentFloor && elevator.externalQueue.getHead().getDirection().equals(elevator.direction)) {
elevator.currentFloor--;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else if (elevator.internalQueue.getHead() < elevator.currentFloor) {
elevator.currentFloor--;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
} else {
elevator.direction = "UP";
elevator.currentFloor++;
System.out.println("Current Floor: " + elevator.getCurrentFloor() + " Direction: " + elevator.getDirection());
}
}
break;
}
}
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int minFloor = scanner.nextInt();
scanner.nextLine();
int maxFloor = scanner.nextInt();
scanner.nextLine();
Elevator elevator = new Elevator(minFloor, maxFloor);
ElevatorController controller = new ElevatorController(elevator);
while (true) {
String input = scanner.nextLine().trim();
if ("end".equalsIgnoreCase(input)) {
break;
}
controller.processInput(input);
}
controller.execute();
scanner.close();
}
}
代码分析：
- 功能实现：在功能实现上，该代码实现了更复杂的电梯调度逻辑。外部请求格式变更为<请求源楼层，请求目的楼层>，并且在处理外部请求后将目的楼层加入内部队列。ElevatorController类的execute方法通过对内外请求队列的判断和处理，实现了电梯的合理调度。在处理请求时，根据电梯当前楼层、请求楼层和方向，以及内外请求队列的情况，通过一系列条件判断来决定电梯的运行方向和停靠楼层。虽然代码逻辑相对严谨，但在处理内外请求同时存在的情况时，条件判断较为复杂，可读性有待提高。
- 代码质量：在代码质量方面，输入校验更加完善，通过isValidFloor方法对输入的楼层进行合法性检查，确保输入的楼层在电梯的有效范围内，提高了程序的健壮性。同时，代码的结构更加清晰，类和方法的职责明确，提高了代码的可维护性。然而，代码中仍然存在一些可以优化的地方，例如在execute方法中，对于不同情况的处理逻辑可以进一步简化，以提高代码的可读性和执行效率。此外，代码中的注释仍然相对较少，对于一些复杂的逻辑部分，需要进一步添加注释以方便理解。
三、踩坑心得
（一）输入处理问题
在编写这三个代码的过程中，输入处理是一个常见的问题。在第一个和第二个代码中，对输入的处理不够严谨，没有充分考虑输入的合法性和边界情况。例如，第一个代码未对输入的楼层和方向进行全面校验，可能导致程序在运行时因非法输入而出现异常，如输入非数字字符或超出电梯楼层范围的数字。第二个代码虽然增加了楼层范围校验，但对于输入格式的其他方面，如方向输入错误（非UP或DOWN ）等情况仍未完全处理，这表明在输入处理方面需要更加全面和细致的考虑。
（二）逻辑复杂度高
三个代码中都存在复杂的逻辑判断，尤其是在处理电梯运行方向和请求处理时。大量使用switch语句和重复的if - else判断逻辑，使得代码的可读性差，维护困难。例如，在处理内外请求同时存在的情况时，需要考虑多种条件组合，这导致代码中出现多层嵌套的判断语句，增加了代码的理解难度。在后续开发中，需要优化逻辑结构，简化复杂的判断流程，提高代码的可读性和可维护性。可以考虑使用更清晰的算法或设计模式来处理这些复杂逻辑，如状态模式或策略模式，将不同的处理逻辑封装成独立的类，降低代码的耦合度。
（三）代码规范与可读性
部分方法命名不规范或不易理解，如第一个代码中的elsehasdownRequest和elsehasupRequest等方法名，从名称上难以直接推断其功能。这种不规范的命名会增加代码阅读和维护的难度，尤其是在多人协作开发的项目中。在编写代码时，应遵循良好的命名规范，使用具有描述性的名称，使代码能够清晰地表达其功能。同时，代码中的注释较少，对于关键逻辑部分没有足够的解释，这也不利于代码的理解和维护。在复杂的逻辑判断和重要的方法中，应添加详细的注释，说明代码的意图和实现思路，提高代码的可读性。
四、自我感觉应该改进的地方
（一）优化逻辑结构
对于复杂的电梯运行逻辑，可进一步拆分方法，使每个方法只负责单一功能，降低代码的复杂度。以电梯移动逻辑为例，可以将电梯向上移动、向下移动以及停靠开门关门等操作分别封装到独立的方法中，如moveUp、moveDown、openDoorAtFloor和closeDoor等方法。这样，在处理电梯运行时，通过调用这些单一功能的方法，使代码逻辑更加清晰，易于理解和维护。同时，在处理请求队列时，可以采用更高效的数据结构或算法，如优先队列，根据请求的优先级或其他条件对请求进行排序，优化电梯的调度策略，提高电梯的运行效率。
（二）增强输入校验
在所有代码中，进一步完善输入校验逻辑。不仅要校验楼层范围，还应校验方向的合法性，确保输入的方向只能是UP或DOWN。同时，对输入格式进行严格检查，如输入的请求是否符合<楼层数>或<楼层数,方向>的格式，对于不符合格式的输入进行提示并要求重新输入。可以使用正则表达式来进行输入格式的校验，提高校验的准确性和效率。此外，还应考虑输入的边界情况，如输入的楼层为电梯的最大或最小楼层时的处理，以及输入为空或非法字符时的处理，确保程序能够处理各种非法输入情况，提高程序的健壮性。
（三）规范代码命名
对方法和变量进行更规范、更具描述性的命名。在命名方法时，应准确反映方法的功能，避免使用含义模糊的名称。例如，将elsehasdownRequest方法改名为handleDownwardRequestsWhenDirectionDiffers，这样的命名能够更清晰地表达方法的功能，使其他开发者能够快速理解代码的意图。在命名变量时，也应遵循同样的原则，使用具有描述性的名称，如将表示电梯当前楼层的变量currentFloor保持不变，而对于一些临时变量，应根据其用途进行合理命名，避免使用过于简单或无意义的名称。
（四）添加注释
在关键代码处添加注释，解释代码的功能和逻辑。在复杂的逻辑判断和重要的方法中，注释尤为重要。例如，在ElevatorController类的execute方法中，对于复杂的条件判断部分，可以添加注释说明每个条件分支的作用和适用场景。在Elevator类的构造方法中，注释应说明各个属性的初始化目的和默认值的意义。通过添加注释，不仅可以帮助其他开发者快速理解代码，也有助于自己在后续维护和扩展代码时能够迅速回忆起代码的实现思路，提高代码的可读性和可维护性。
五、总结
（一）学习心得
通过这三个代码的编写和分析，对 Java 面向对象编程有了更深入的理解。学会了如何设计合理的类结构，将属性和方法进行封装，以及通过类之间的协作实现复杂的功能。同时，也深刻认识到代码质量的重要性，包括代码的可读性、可维护性和健壮性。在编写代码过程中，要注重细节，充分考虑各种边界情况和异常处理，提高程序的稳定性。此外，合理的逻辑设计和规范的代码编写习惯能够大大提高开发效率，减少代码中的错误和漏洞。在后续的学习和开发中，将更加注重代码的设计和规范，不断提高编程能力，以应对更复杂的项目需求。
（二）对课程的建议
希望在课程学习中，能有更多关于代码优化和设计模式的讲解。通过实际案例分析，帮助理解如何运用设计模式优化代码结构，提高代码的可维护性和可扩展性。例如，在电梯调度系统中，可以讲解如何使用状态模式来管理电梯的不同运行状态，使代码更加清晰和易于维护。同时，可以提供更多实际项目案例，让学生在实践中掌握编程技能，提高解决实际问题的能力。案例的难度可以逐步递增，从简单的功能实现到复杂的系统设计，让学生在实践中不断积累经验，提高编程水平。此外，加强代码审查和反馈环节，通过对学生代码的审查，及时指出存在的问题和改进方向，帮助学生更快地提高代码质量。
尾话：
这电梯太恶心了
-----------------------------------------------------------------------------------------------------------------------------------------24201321-黄永铎
