第一次blog作业

1.前言：
Java 电梯题目集 7 总结与成长回顾
在完成 Java 电梯题目集 7 的过程中，我在知识点、题量、难度方面有了诸多收获，自身编程能力也实现了显著成长。
一、知识点总结
在类的设计与封装方面，我从题目集 7 将电梯调度功能集中在一个类的 “粗犷” 方式，逐步成长为在题目集 7 中，依据单一职责原则，把电梯调度功能拆解为电梯状态管理（Elevator 类）、请求管理（RequestQueue 类）、控制调度（Controller 类）等多个类，有效降低了代码耦合度，增强了程序的可维护性与可扩展性。对象的创建与使用贯穿整个题目集，我熟练掌握了创建各类对象并合理调用其方法的技巧，通过创建 Elevator 对象模拟电梯运行，创建 RequestQueue 对象管理请求队列，实现电梯系统的各项功能。队列数据结构的应用也十分关键，利用内部和外部请求队列存储乘客的楼层、方向等请求信息，为电梯调度算法提供决策依据。逻辑判断与流程控制上，我学会运用 if - else、switch 等分支语句，处理电梯运行方向判断、是否停靠楼层判断等复杂逻辑。输入输出处理方面，我能够根据不同题目集的要求，灵活处理乘客请求信息的输入以及电梯运行状态、停靠楼层等信息的输出，尤其是在题目集 7 输入格式变化时，快速调整输入处理逻辑。
二、题量与难度情况
虽然每次题目集仅有一道题目，但题量背后的实际工作量不容小觑。题目集 7 作为基础，要求实现基本的电梯调度功能，此时电梯调度功能集中在一个类中实现，代码耦合度高、复杂度大，难度较高。题目集 6 在此基础上，着重考察对单一职责原则的应用，将不同功能模块拆分到多个类中，同时需要处理无效楼层请求、连续相同请求等特殊情况，难度进一步提升。到了题目集 7，引入乘客类并修改请求输入格式，要求对电梯调度程序进行更深入的优化，不仅要遵循 SRP 原则，还要处理新的请求逻辑和数据流转，难度再次升级，对综合编程能力和逻辑分析能力提出了更高要求。
三、个人成长
从编程能力上看，我对 Java 语言的掌握更加熟练，尤其是在类与对象、数据结构、流程控制等核心知识点的运用上。在面对复杂问题时，能够运用设计原则合理规划代码结构，使程序更加清晰、易维护。逻辑思维能力也得到了极大锻炼，在处理电梯调度的各种复杂逻辑判断和流程控制时，思维更加严谨、有条理。在解决问题的能力方面，从最初面对题目集 5 的手足无措，到题目集 7 能够快速分析需求变化并调整代码，解决问题的效率和质量都有了显著提高。同时，在不断优化代码的过程中，我也培养了良好的代码优化意识，学会从可维护性、可扩展性等多方面综合考量代码质量。

2.设计与分析：
行数：208行
语句数：120条
分支语句百分比：13.3
方法调用语句数：55 条
注释行百分比：4.3% ，即代码无注释
类和接口数量：1个
每个类的平均方法数：4.3 个
每个方法的平均语句数）：11.64 条
最复杂方法的行号：82 行
最深代码块行号：119 行
最大代码块深度为 6
平均代码块深度：2.67
平均复杂度：5.45
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

// 乘客类
class Passenger {
private int sourceFloor;
private int destinationFloor;

public Passenger(int sourceFloor, int destinationFloor) {
    this.sourceFloor = sourceFloor;
    this.destinationFloor = destinationFloor;
}

public int getSourceFloor() {
    return sourceFloor;
}

public int getDestinationFloor() {
    return destinationFloor;
}

}

// 队列类
class RequestQueue {
private Queue externalQueue;
private Queue internalQueue;

public RequestQueue() {
    externalQueue = new LinkedList<>();
    internalQueue = new LinkedList<>();
}

public void addExternalRequest(Passenger passenger) {
    externalQueue.add(passenger);
}

public void addInternalRequest(int floor) {
    internalQueue.add(floor);
}

public Passenger getNextExternalRequest() {
    return externalQueue.poll();
}

public Integer getNextInternalRequest() {
    return internalQueue.poll();
}

public boolean hasExternalRequests() {
    return !externalQueue.isEmpty();
}

public boolean hasInternalRequests() {
    return !internalQueue.isEmpty();
}

}

// 电梯类
class Elevator {
private int currentFloor;
private int minFloor;
private int maxFloor;
private int direction; // 1 表示向上，-1 表示向下
private RequestQueue requestQueue;

public Elevator(int minFloor, int maxFloor) {
    this.currentFloor = minFloor;
    this.minFloor = minFloor;
    this.maxFloor = maxFloor;
    this.direction = 1;
    this.requestQueue = new RequestQueue();
}

public void addExternalRequest(Passenger passenger) {
    // 验证输入的楼层是否在有效范围内
    if (isValidFloor(passenger.getSourceFloor()) && isValidFloor(passenger.getDestinationFloor())) {
        requestQueue.addExternalRequest(passenger);
    } else {
        System.out.println("Invalid floor request: " + passenger.getSourceFloor() + ", " + passenger.getDestinationFloor());
    }
}

public void addInternalRequest(int floor) {
    // 验证输入的楼层是否在有效范围内
    if (isValidFloor(floor)) {
        requestQueue.addInternalRequest(floor);
    } else {
        System.out.println("Invalid floor request: " + floor);
    }
}

public void run() {
    while (requestQueue.hasExternalRequests() || requestQueue.hasInternalRequests()) {
        if (requestQueue.hasExternalRequests()) {
            Passenger passenger = requestQueue.getNextExternalRequest();
            moveToFloor(passenger.getSourceFloor());
            openDoor(passenger.getSourceFloor());
            closeDoor();
            requestQueue.addInternalRequest(passenger.getDestinationFloor());
        }
        if (requestQueue.hasInternalRequests()) {
            int destinationFloor = requestQueue.getNextInternalRequest();
            moveToFloor(destinationFloor);
            openDoor(destinationFloor);
            closeDoor();
        }
    }
}

private void moveToFloor(int destinationFloor) {
    if (destinationFloor > currentFloor) {
        direction = 1;
        while (currentFloor < destinationFloor) {
            currentFloor++;
            printStatus();
        }
    } else if (destinationFloor < currentFloor) {
        direction = -1;
        while (currentFloor > destinationFloor) {
            currentFloor--;
            printStatus();
        }
    }
}

private void openDoor(int floor) {
    System.out.println("Open Door # Floor " + floor);
}

private void closeDoor() {
    System.out.println("Close Door");
}

private void printStatus() {
    String directionStr = direction == 1 ? "UP" : "DOWN";
    System.out.println("Current Floor: " + currentFloor + " Direction: " + directionStr);
}

// 验证楼层是否在有效范围内
private boolean isValidFloor(int floor) {
    return floor >= minFloor && floor <= maxFloor;
}

}

// 控制类
class ElevatorController {
private Elevator elevator;

public ElevatorController(int minFloor, int maxFloor) {
    this.elevator = new Elevator(minFloor, maxFloor);
}

public void handleRequest(String request) {
    if (request.startsWith("<") && request.endsWith(">")) {
        request = request.substring(1, request.length() - 1);
        if (request.contains(",")) {
            String[] parts = request.split(",");
            try {
                int sourceFloor = Integer.parseInt(parts[0]);
                int destinationFloor = Integer.parseInt(parts[1]);
                elevator.addExternalRequest(new Passenger(sourceFloor, destinationFloor));
            } catch (NumberFormatException e) {
                System.out.println("Invalid request format: " + request);
            }
        } else {
            try {
                int floor = Integer.parseInt(request);
                elevator.addInternalRequest(floor);
            } catch (NumberFormatException e) {
                System.out.println("Invalid request format: " + request);
            }
        }
    } else {
        System.out.println("Invalid request format: " + request);
    }
}

public void startElevator() {
    elevator.run();
}

}

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();

    // 验证最小楼层和最大楼层的有效性
    if (minFloor > maxFloor) {
        System.out.println("Invalid floor range: minFloor > maxFloor");
        return;
    }

    ElevatorController controller = new ElevatorController(minFloor, maxFloor);

    String input;
    while (!(input = scanner.nextLine().trim().toLowerCase()).equals("end")) {
        controller.handleRequest(input);
    }

    controller.startElevator();
    scanner.close();
}

}
代码实现了一个电梯调度系统，以下是对代码的详细总结：
整体功能概述
该代码模拟了一个电梯调度系统的运行，用户可以输入最小楼层、最大楼层以及乘客的请求（包括电梯外请求 <请求源楼层，请求目的楼层> 和电梯内请求 <楼层数>），系统会根据这些请求模拟电梯的运行过程，输出电梯的运行状态和开关门信息。
主要类及其功能

Passenger 类
功能：表示一个乘客的请求，包含请求源楼层 sourceFloor 和请求目的楼层 destinationFloor。
方法：
Passenger(int sourceFloor, int destinationFloor)：构造函数，用于初始化乘客的请求信息。
getSourceFloor()：获取请求源楼层。
getDestinationFloor()：获取请求目的楼层。
RequestQueue 类
功能：管理电梯的外部请求队列和内部请求队列。
方法：
RequestQueue()：构造函数，初始化外部请求队列 externalQueue 和内部请求队列 internalQueue。
addExternalRequest(Passenger passenger)：向外部请求队列添加乘客请求。
addInternalRequest(int floor)：向内部请求队列添加楼层请求。
getNextExternalRequest()：获取并移除外部请求队列的下一个请求。
getNextInternalRequest()：获取并移除内部请求队列的下一个请求。
hasExternalRequests()：判断外部请求队列是否还有请求。
hasInternalRequests()：判断内部请求队列是否还有请求。
Elevator 类
功能：负责电梯的运行逻辑，包括移动到指定楼层、开门、关门等操作。
方法：
Elevator(int minFloor, int maxFloor)：构造函数，初始化电梯的当前楼层、最小楼层、最大楼层、运行方向和请求队列。
addExternalRequest(Passenger passenger)：添加外部请求，并验证请求的楼层是否在有效范围内。
addInternalRequest(int floor)：添加内部请求，并验证请求的楼层是否在有效范围内。
run()：电梯运行主逻辑，处理外部请求和内部请求。
moveToFloor(int destinationFloor)：将电梯移动到指定楼层，并输出电梯的运行状态。
openDoor(int floor)：打开指定楼层的电梯门。
closeDoor()：关闭电梯门。
printStatus()：输出电梯的当前楼层和运行方向。
isValidFloor(int floor)：验证楼层是否在有效范围内。
ElevatorController 类
功能：处理用户输入的请求，并启动电梯运行。
方法：
ElevatorController(int minFloor, int maxFloor)：构造函数，初始化电梯控制器并创建电梯对象。
handleRequest(String request)：解析用户输入的请求，将其转换为相应的电梯请求，并添加到电梯的请求队列中。
startElevator()：启动电梯运行。
ElevatorScheduling 类
功能：程序的入口点，负责读取用户输入，创建电梯控制器并启动电梯调度系统。
方法：
main(String[] args)：主函数，读取用户输入的最小楼层、最大楼层和乘客请求，验证输入的有效性，创建电梯控制器并启动电梯运行。
总结：
总体而言，写电梯题目从不会慌张到慢慢开始摸索写出这道题还是很开心的，也希望在后续的Java课程学习中也能继续保持这份热情和慢慢摸索的这份动力

posted @ 2025-04-20 21:33 哈哈耶阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

lh20070225

第一次blog作业

公告