题目集5~7的总结性Blog

04/18/2025 19:06:22

前言：

这是我的总结Blog 老师要求我有严谨的行文风格，格式规范，严禁抄袭和使用AI生成内容，我当然会完成。但我不知道我含辛茹苦、认认真真写的Blog会不会有人同等认真的对待。大概率看的是助教同学你好!

起码我到现在也没有被PTA查重查到说明老师们的判断是准确的要是把我认认真真写了这么久的代码判断抄袭了我会气到七窍流血的。

我觉得五六七次的题目集都有一个同性就是难每一个题目集的题目都够我思考很久有时候一个题目能写我好几天的时间但是段老师不想我们说代码很难。那就说说考察什么知识点了、这几次的题目集是我学习面向对象的唯一途径，我被迫详细的了解了封装：封装是将对象的属性和行为（方法）捆绑在一起，并隐藏对象的内部表示（状态）。通过封装，可以限制对对象内部状态的直接访问，只能通过对象提供的方法来操作数据。比如类里面的getter和setter的方法 static ：static 关键字用于声明类的静态成员（变量或方法）。静态成员属于类本身，而不是类的实例。这意味着无论创建多少个类的实例，静态成员都只有一份，并且可以通过类名直接访问，而不需要创建类的实例。 public：public 是一种访问修饰符，表示该成员（变量、方法或类）可以被任何其他类访问。public 关键字通常用于定义类的接口，使得其他类可以调用这些方法或访问这些变量。 private：private 也是一种访问修饰符，表示该成员（变量、方法）只能在定义它的类内部访问。private 关键字用于实现封装，保护类的内部状态不被外部直接访问，从而确保类的完整性和安全性。

分析代码和心得：

（为什么不能折叠啊？？？？？）

可以按下面那个箭头👇

5-3

  
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

enum Direction {
    UP,
    DOWN,
    IDLE;
}

enum State {
    MOVING,
    STOPPED;
}

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 输入电梯的最小和最大楼层数
        int minFloor = sc.nextInt();
        int maxFloor = sc.nextInt();
        sc.nextLine(); // 消耗换行符

        Elevator elevator = new Elevator();
        elevator.setMinFloor(minFloor);
        elevator.setMaxFloor(maxFloor);
        RequestQueue queue = new RequestQueue();

        String tem = null;
        while (true) {
            String input = sc.nextLine().trim();

            // 检查是否输入结束标志
            if (input.equalsIgnoreCase("end")) {
                break;
            }

            // 匹配电梯内请求格式
            Pattern innerPattern = Pattern.compile("^<\\d+>$");
            Matcher innerMatcher = innerPattern.matcher(input);
            if (innerMatcher.matches()) {
                int aimFloor = Integer.parseInt(input.substring(1, input.length() - 1));

                // 检查楼层数是否在有效范围内
                if (aimFloor < elevator.getMinFloor() || aimFloor > elevator.getMaxFloor() || input.equals(tem)) {
                    continue;
                }
                internalRequest temp = new internalRequest(aimFloor);

                // 创建电梯内请求对象并存储
                queue.getInRequests().add(temp);
            }
            // 匹配电梯外请求格式
            else {
                Pattern outerPattern = Pattern.compile("^<(\\d+),(UP|DOWN)>$");
                Matcher outerMatcher = outerPattern.matcher(input);
                if (outerMatcher.matches()) {
                    int atFloor = Integer.parseInt(outerMatcher.group(1)); // 楼层数
                    String aimDirection = outerMatcher.group(2); // 方向

                    // 检查楼层数是否在有效范围内
                    if (atFloor < elevator.getMinFloor() || atFloor > elevator.getMaxFloor() || input.equals(tem)) {
                        continue;
                    }

                    // 创建电梯外请求对象并存储
                    externalRequest temp = new externalRequest(atFloor, aimDirection);
                    queue.getOutRequests().add(temp);
                }
            }
            tem = input;
        }
        Controler controler = new Controler(elevator, queue);
        controler.MOVE();
    }
}

// 电梯外乘客请求格式：<乘客所在楼层数,乘梯方向>，其中，乘梯方向用UP代表上行，用DOWN代表下行（UP、DOWN必须大写）。

class externalRequest {
    private int AtFloor; // 乘客所在楼层数
    private String AimDirection;

    public externalRequest() {
    }

    public externalRequest(int atFloor, String aimDirection) {
        AtFloor = atFloor;
        AimDirection = aimDirection;
    }

    public int getAtFloor() {
        return AtFloor;
    }

    public void setAtFloor(int atFloor) {
        AtFloor = atFloor;
    }

    public String getAimDirection() {
        return AimDirection;
    }

    public void setAimDirection(String aimDirection) {
        AimDirection = aimDirection;
    }
}

// 电梯内乘客请求格式：<楼层数>
class internalRequest {
    private int AimFloor; // 目标楼层数

    public internalRequest() {
    }

    public internalRequest(int aimFloor) {
        AimFloor = aimFloor;
    }

    public int getAimFloor() {
        return AimFloor;
    }

    public void setAimFloor(int aimFloor) {
        AimFloor = aimFloor;
    }
}

class Elevator {
    private int MaxFloor;
    private int MinFloor = 1;
    private String Directions = "UP"; // 方向
    private boolean state; // 运动状态
    private int currentFloor = 1;

    public Elevator() {
    }

    public Elevator(int maxFloor, int minFloor, String directions, boolean state) {
        MaxFloor = maxFloor;
        MinFloor = minFloor;
        Directions = directions;
        this.state = state;
        currentFloor = 1;
    }

    public int getMaxFloor() {
        return MaxFloor;
    }

    public void setMaxFloor(int maxFloor) {
        MaxFloor = maxFloor;
    }

    public int getMinFloor() {
        return MinFloor;
    }

    public void setMinFloor(int minFloor) {
        MinFloor = minFloor;
    }

    public String getDirections() {
        return Directions;
    }

    public void setDirections(String directions) {
        Directions = directions;
    }

    public boolean getState() {
        return state;
    }

    public void setState(boolean state) {
        this.state = state;
    }

    public int getcurrentFloor() {
        return currentFloor;
    }

    public void setCurrentFloor(int currentFloor) {
        this.currentFloor = currentFloor;
    }
}

class RequestQueue {
    private ArrayList inRequests = new ArrayList<>();
    private ArrayList outRequests = new ArrayList<>();

    public ArrayList getInRequests() {
        return inRequests;
    }

    public void setInRequests(ArrayList inRequests) {
        this.inRequests = inRequests;
    }

    public ArrayList getOutRequests() {
        return outRequests;
    }

    public void setOutRequests(ArrayList outRequests) {
        this.outRequests = outRequests;
    }
}

class Controler {
    private Elevator elevator;
    private RequestQueue queue;
    private int aimfloor = 0;

    public Controler(Elevator elevator, RequestQueue queue) {
        this.elevator = elevator;
        this.queue = queue;
    }

    public Controler() {
    }

    public Elevator getElevator() {
        return elevator;
    }

    public void setElevator(Elevator elevator) {
        this.elevator = elevator;
    }

    public RequestQueue getQueue() {
        return queue;
    }

    public void setQueue(RequestQueue queue) {
        this.queue = queue;
    }

    public void delet() {
        if (!queue.getInRequests().isEmpty()) {
            if (queue.getInRequests().get(0).getAimFloor() == elevator.getcurrentFloor())
                queue.getInRequests().remove(0);
        }
        if (!queue.getOutRequests().isEmpty()) {
            if (queue.getOutRequests().get(0).getAimDirection().equals(elevator.getDirections()) && queue.getOutRequests().get(0).getAtFloor() == elevator.getcurrentFloor())
                queue.getOutRequests().remove(0);
        }
    }

    public void DirectionSet() {
        if (!queue.getInRequests().isEmpty()) {
            aimfloor = queue.getInRequests().get(0).getAimFloor();
        } else if (!queue.getOutRequests().isEmpty()) {
            aimfloor = queue.getOutRequests().get(0).getAtFloor();
            queue.getOutRequests().remove(0);
        }
        if (aimfloor >= elevator.getcurrentFloor())
            elevator.setDirections("UP");
        else
            elevator.setDirections("DOWN");
    }

    public boolean makeaturn() {
        boolean hasinter = false;
        boolean hasexternal = false;
        boolean result = false;
        boolean up = elevator.getDirections().equals("UP");
        if (up) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() >= elevator.getcurrentFloor())
                    hasinter = true;
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() > elevator.getcurrentFloor())
                    hasexternal = true;
            }
        } else if (!up) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() <= elevator.getcurrentFloor())
                    hasinter = true;
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() < elevator.getcurrentFloor())
                    hasexternal = true;
            }
        }
        if (!hasexternal && !hasinter)
            result = true;
        return result;
    }

    public void determineDirecion() {
        boolean up = elevator.getDirections().equals("UP");
        int aim = -10086;
        if (makeaturn()) {
            up = !up;
        }
        if (up) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() > elevator.getcurrentFloor() && up) {
                    aim = queue.getInRequests().get(0).getAimFloor();
                }
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() > elevator.getcurrentFloor()) {
                    if (aim != -10086)
                        aimfloor = (Math.abs(elevator.getcurrentFloor() - aim) > Math.abs(elevator.getcurrentFloor() - queue.getOutRequests().get(0).getAtFloor())) ? queue.getOutRequests().get(0).getAtFloor() : aim;
                    else
                        aimfloor = queue.getOutRequests().get(0).getAtFloor();
                } else
                    aimfloor = aim;
            } else {
                aimfloor = aim;
            }

        } else {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() < elevator.getcurrentFloor() && !up)
                    aim = queue.getInRequests().get(0).getAimFloor();
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() < elevator.getcurrentFloor()) {
                    if (aim != -10086)
                        aimfloor = (Math.abs(elevator.getcurrentFloor() - aim) > Math.abs(elevator.getcurrentFloor() - queue.getOutRequests().get(0).getAtFloor())) ? queue.getOutRequests().get(0).getAtFloor() : aim;
                    else
                        aimfloor = queue.getOutRequests().get(0).getAtFloor();
                } else
                    aimfloor = aim;
            } else {
                aimfloor = aim;
            }

        }
        if (up)
            elevator.setDirections("UP");
        else
            elevator.setDirections("DOWN");
    }

    public void isget() {
        if (!queue.getInRequests().isEmpty()) {
            if (elevator.getcurrentFloor() == queue.getInRequests().get(0).getAimFloor()) {
                delet();
                elevator.setState(false);
            }
        }
        if (!queue.getOutRequests().isEmpty()) {
            if (elevator.getcurrentFloor() == queue.getOutRequests().get(0).getAtFloor() && queue.getOutRequests().get(0).getAimDirection().equals(elevator.getDirections())) {
                delet();
                elevator.setState(false);
            }
        }
    }

    public void outmessage() {
        System.out.println("Current Floor: " + elevator.getcurrentFloor() + " Direction: " + elevator.getDirections());
    }

    public void open() {
        if (elevator.getState() == false) {
            System.out.println("Open Door # Floor " + elevator.getcurrentFloor());
            System.out.println("Close Door");
            elevator.setState(true);
        }
    }

    public void MOVE() {
        boolean fir = true;
        elevator.setState(true);
        DirectionSet();
        int aim = aimfloor;
        while (true) {
            if (queue.getInRequests().isEmpty() && queue.getOutRequests().isEmpty())
                break;
            if (!fir) {
                determineDirecion();
                isget();
                delet();
                open();
                determineDirecion();
                aim = aimfloor;
            } else
                outmessage();
            if (queue.getInRequests().isEmpty() && queue.getOutRequests().isEmpty())
                break;
            if (elevator.getDirections().equals("UP")) {
                while (elevator.getcurrentFloor() != aim) {
                    elevator.setCurrentFloor(elevator.getcurrentFloor() + 1);
                    outmessage();
                    determineDirecion();
                    isget();
                    delet();
                    open();
                }
                aim = aimfloor;
            } else if (elevator.getDirections().equals("DOWN")) {
                while (elevator.getcurrentFloor() != aim) {
                    elevator.setCurrentFloor(elevator.getcurrentFloor() - 1);
                    outmessage();
                    determineDirecion();
                    isget();
                    delet();
                    open();
                }
                aim = aimfloor;
            }
            fir = false;
        }
    }
}

我个人是真心的认为这个作为初始代码是很不错的了，这是我第一次在PTA见到这种大型的题目，一开始着实吓一跳，但现在轻舟已过万重山。回头再看这段代码写的还是一坨。

先将方法解释一下

`determineDirecion()`

这个方法用于确定电梯的运行方向。

根据请求队列中的请求，确定电梯的运行方向。

调用 makeaturn() 方法判断是否需要改变方向。
如果需要改变方向，则将方向反转。
根据电梯的当前方向和请求队列中的目标楼层，确定新的目标楼层。

`DirectionSet()`

这个方法用于设置电梯的运行方向。

根据请求队列中的目标楼层，设置电梯的运行方向（UP 或 DOWN）。

如果电梯内有请求，则目标楼层为队列中第一个请求的目标楼层。
如果电梯外有请求，则目标楼层为队列中第一个请求的所在楼层，并且从队列中移除该请求。
根据目标楼层与电梯当前楼层的比较，设置电梯的方向为 UP 或 DOWN。

makeaturn()

这个方法用于判断电梯是否需要改变方向。

- 根据电梯的当前方向（UP 或 DOWN），检查请求队列中的请求是否与当前方向一致。
- 如果电梯当前向上运行，检查是否有请求在当前楼层之上；如果没有，则返回 true，表示需要改变方向。
- 如果电梯当前向下运行，检查是否有请求在当前楼层之下；如果没有，则返回 true，表示需要改变方向。

`isget()`

这个方法用于检查电梯是否到达了请求的目标楼层。

检查电梯内的请求队列，如果电梯当前所在的楼层等于队列中第一个请求的目标楼层，则调用 delet() 方法删除该请求，并将电梯状态设置为停止。
检查电梯外的请求队列，如果电梯当前所在的楼层等于队列中第一个请求的所在楼层，并且电梯的运行方向与请求的方向一致，则调用 delet() 方法删除该请求，并将电梯状态设置为停止

`MOVE()`

这个方法是电梯运行的核心逻辑。

控制电梯的运行逻辑，包括移动电梯、处理请求、输出状态等。

- 设置电梯的初始方向。
- 进入循环，直到所有请求处理完毕。
- 根据电梯的方向和目标楼层，移动电梯。
- 在每次移动后，调用 outmessage() 方法输出电梯的当前状态。
- 调用 determineDirecion() 方法确定新的方向。
- 调用 isget() 方法检查是否到达了请求的目标楼层。
- 调用 delet() 方法删除已完成的请求。
- 调用 open() 方法模拟电梯门的开关。

我现在来解释一下我对这个电梯的理解你要是说“欸你图怎么画这么丑啊？”WHO CARES！回答我！有人会看吗！没有！好的往下看吧

假设这是题目给出的<3><2,DOWN><4><5,UP><7>这样的代码

电梯开始移动第一次决定方向会以初始楼层对比第一个最近的请求来决定初始方向。我们会在每次到新的楼层比较内外请求的第一个楼层请求。并且方向优先所以电梯不会在2层停靠。

当我们到达三层时我们将三层删除 ! 然后再继续移动。

按照这个逻辑我们就会输出这样的结果说句实话和大家常规理解的电梯有很大区别。🤨 我记得我家的电梯还没这个聪明。

Current Floor: 1 Direction: UP
Current Floor: 2 Direction: UP
Current Floor: 3 Direction: UP
Open Door # Floor 3
Close Door
Current Floor: 4 Direction: UP
Open Door # Floor 4
Close Door
Current Floor: 5 Direction: UP
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Open Door # Floor 7
Close Door
Current Floor: 6 Direction: DOWN
Current Floor: 5 Direction: DOWN
Current Floor: 4 Direction: DOWN
Current Floor: 3 Direction: DOWN
Current Floor: 2 Direction: DOWN
Open Door # Floor 2
Close Door
Current Floor: 3 Direction: UP
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Open Door # Floor 5
Close Door

6-3

  
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

enum Direction {
    UP,
    DOWN,
    IDLE;
}

enum State {
    MOVING,
    STOPPED;
}

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 输入电梯的最小和最大楼层数
        int minFloor = sc.nextInt();
        int maxFloor = sc.nextInt();
        sc.nextLine(); // 消耗换行符

        Elevator elevator = new Elevator();
        elevator.setMinFloor(minFloor);
        elevator.setMaxFloor(maxFloor);
        RequestQueue queue = new RequestQueue();

        String tem=null;
        while (true) {
            String input = sc.nextLine().trim();

            // 检查是否输入结束标志
            if (input.equalsIgnoreCase("end")) {
                break;
            }

            // 匹配电梯内请求格式
            Pattern innerPattern = Pattern.compile("^<\\d+>$");
            Matcher innerMatcher = innerPattern.matcher(input);
            if (innerMatcher.matches()) {
                int aimFloor = Integer.parseInt(input.substring(1, input.length() - 1));

                // 检查楼层数是否在有效范围内
                if (aimFloor < elevator.getMinFloor() || aimFloor > elevator.getMaxFloor() || input.equals(tem)) {
                    continue;
                }
                internalRequest temp = new internalRequest(aimFloor);

                // 创建电梯内请求对象并存储
                queue.getInRequests().add(temp);
            }
            // 匹配电梯外请求格式
            else {
                Pattern outerPattern = Pattern.compile("^<(\\d+),(UP|DOWN)>$");
                Matcher outerMatcher = outerPattern.matcher(input);
                if (outerMatcher.matches()) {
                    int atFloor = Integer.parseInt(outerMatcher.group(1)); // 楼层数
                    String aimDirection = outerMatcher.group(2); // 方向

                    // 检查楼层数是否在有效范围内
                    if (atFloor < elevator.getMinFloor() || atFloor > elevator.getMaxFloor() || input.equals(tem)) {
                        continue;
                    }

                    // 创建电梯外请求对象并存储
                    externalRequest temp = new externalRequest(atFloor, aimDirection);
                    queue.getOutRequests().add(temp);
                }
            }
            tem=input;
        }
        Controler controler = new Controler(elevator,queue);
        controler.MOVE();

    }

}

// 电梯外乘客请求格式：<乘客所在楼层数,乘梯方向>，其中，乘梯方向用UP代表上行，用DOWN代表下行（UP、DOWN必须大写）。

class externalRequest {
    private int AtFloor; // 乘客所在楼层数
    private String AimDirection;

    public externalRequest() {
    }

    public externalRequest(int atFloor, String aimDirection) {
        AtFloor = atFloor;
        AimDirection = aimDirection;
    }

    public int getAtFloor() {
        return AtFloor;
    }

    public void setAtFloor(int atFloor) {
        AtFloor = atFloor;
    }

    public String getAimDirection() {
        return AimDirection;
    }

    public void setAimDirection(String aimDirection) {
        AimDirection = aimDirection;
    }
}
// 电梯内乘客请求格式：<楼层数>
class internalRequest {
    private int AimFloor; // 目标楼层数

    public internalRequest() {
    }

    public internalRequest(int aimFloor) {
        AimFloor = aimFloor;
    }

    public int getAimFloor() {
        return AimFloor;
    }

    public void setAimFloor(int aimFloor) {
        AimFloor = aimFloor;
    }
}
class Elevator {
    // 包含电梯的最大楼层数、最小楼层数（默认为1层）当前楼层、运行方向、运行状态，
    // 以及电梯内部乘客的请求队列和电梯外部楼层乘客的请求队列，其中，电梯外部请求队列需要区分上行和下行。
    private int MaxFloor;
    private int MinFloor = 1;
    private String Directions = "UP"; // 方向
    private boolean state; // 运动状态
    private int currentFloor = 1;

    public Elevator() {
    }

    public Elevator(int maxFloor, int minFloor, String directions, boolean state) {
        MaxFloor = maxFloor;
        MinFloor = minFloor;
        Directions = directions;
        this.state = state;
        currentFloor = 1;
    }

    public int getMaxFloor() {
        return MaxFloor;
    }

    public void setMaxFloor(int maxFloor) {
        MaxFloor = maxFloor;
    }

    public int getMinFloor() {
        return MinFloor;
    }

    public void setMinFloor(int minFloor) {
        MinFloor = minFloor;
    }

    public String getDirections() {
        return Directions;
    }

    public void setDirections(String directions) {
        Directions = directions;
    }

    public boolean getState() {
        return state;
    }

    public void setState(boolean state) {
        this.state = state;
    }

    public int getcurrentFloor() {
        return currentFloor;
    }

    public void setCurrentFloor(int currentFloor) {
        this.currentFloor = currentFloor;
    }

}
class RequestQueue
{
    private ArrayList<internalRequest> inRequests = new ArrayList<>();
    private ArrayList<externalRequest> outRequests = new ArrayList<>();

    public ArrayList<internalRequest> getInRequests() {
        return inRequests;
    }

    public void setInRequests(ArrayList<internalRequest> inRequests) {
        this.inRequests = inRequests;
    }

    public ArrayList<externalRequest> getOutRequests() {
        return outRequests;
    }

    public void setOutRequests(ArrayList<externalRequest> outRequests) {
        this.outRequests = outRequests;
    }

}
class Controler{
    private Elevator elevator;
    private RequestQueue queue;
    private int aimfloor=0;
    public Controler(Elevator elevator, RequestQueue queue) {
        this.elevator = elevator;
        this.queue = queue;
    }

    public Controler() {
    }

    public Elevator getElevator() {
        return elevator;
    }

    public void setElevator(Elevator elevator) {
        this.elevator = elevator;
    }

    public RequestQueue getQueue() {
        return queue;
    }

    public void setQueue(RequestQueue queue) {
        this.queue = queue;
    }

    public void delet() {
        if (!queue.getInRequests().isEmpty()) {
            if (queue.getInRequests().get(0).getAimFloor() == elevator.getcurrentFloor())
                queue.getInRequests().remove(0);
        }
        if (!queue.getOutRequests().isEmpty()) {
            if (queue.getOutRequests().get(0).getAimDirection().equals(elevator.getDirections()) && queue.getOutRequests().get(0).getAtFloor() == elevator.getcurrentFloor())
                queue.getOutRequests().remove(0);
        }
    }

    public void DirectionSet() {
        if (!queue.getInRequests().isEmpty()) {
            aimfloor = queue.getInRequests().get(0).getAimFloor();
        } else if (!queue.getOutRequests().isEmpty()) {
            aimfloor = queue.getOutRequests().get(0).getAtFloor();
            queue.getOutRequests().remove(0);
        }
        if (aimfloor >= elevator.getcurrentFloor())
            elevator.setDirections ("UP");
        else
            elevator.setDirections("DOWN");

    }

    public boolean makeaturn() {
        boolean hasinter=false;
        boolean hasexternal=false;
        boolean result = false;
        boolean up = elevator.getDirections().equals("UP");
        if(up)
        {
            if(!queue.getInRequests().isEmpty()){
                if(queue.getInRequests().get(0).getAimFloor()>=elevator.getcurrentFloor())
                    hasinter=true;
            }
            if (!queue.getOutRequests().isEmpty()) {
                if(queue.getOutRequests().get(0).getAtFloor()>elevator.getcurrentFloor())
                    hasexternal=true;
            }
        }
        else if(!up)
        {
            if(!queue.getInRequests().isEmpty()){
                if(queue.getInRequests().get(0).getAimFloor()<=elevator.getcurrentFloor())
                    hasinter=true;
            }
            if (!queue.getOutRequests().isEmpty()) {
                if(queue.getOutRequests().get(0).getAtFloor()<elevator.getcurrentFloor())
                    hasexternal=true;
            }
        }
        if(!hasexternal&&!hasinter)
            result = true;
        return result;
    }

    public void determineDirecion() {
        boolean up = elevator.getDirections().equals("UP");
        int aim = -10086;
        if (makeaturn()) {
            up = !up;
        }
        if (up) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() > elevator.getcurrentFloor() && up) {
                    aim = queue.getInRequests().get(0).getAimFloor();
                }
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() > elevator.getcurrentFloor() ) {
                    if(aim!=-10086)
                        aimfloor = (Math.abs(elevator.getcurrentFloor() - aim) > Math.abs(elevator.getcurrentFloor() - queue.getOutRequests().get(0).getAtFloor())) ? queue.getOutRequests().get(0).getAtFloor() : aim;
                    else aimfloor=queue.getOutRequests().get(0).getAtFloor();
                } else
                    aimfloor = aim;
            } else {
                aimfloor = aim;
            }

        } else {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getAimFloor() < elevator.getcurrentFloor() && !up)
                    aim = queue.getInRequests().get(0).getAimFloor();
            }
            if (!queue.getOutRequests().isEmpty()) {
                if (queue.getOutRequests().get(0).getAtFloor() < elevator.getcurrentFloor() ) {
                    if(aim!=-10086)
                        aimfloor = (Math.abs(elevator.getcurrentFloor() - aim) > Math.abs(elevator.getcurrentFloor() - queue.getOutRequests().get(0).getAtFloor())) ? queue.getOutRequests().get(0).getAtFloor() : aim;
                    else aimfloor=queue.getOutRequests().get(0).getAtFloor();
                }else
                    aimfloor = aim;
            } else {
                aimfloor = aim;
            }

        }
        if (up)
            elevator.setDirections("UP");
        else
            elevator.setDirections("DOWN");
    }

    public void isget() {
        if (!queue.getInRequests().isEmpty()) {
            if (elevator.getcurrentFloor() == queue.getInRequests().get(0).getAimFloor()) {
                delet();
                elevator.setState(false);
            }
        }
        if (!queue.getOutRequests().isEmpty()) {
            if (elevator.getcurrentFloor() == queue.getOutRequests().get(0).getAtFloor() && queue.getOutRequests().get(0).getAimDirection().equals(elevator.getDirections())) {
                delet();
                elevator.setState(false);
            }
        }
    }

    public void outmessage() {
        System.out.println("Current Floor: " + elevator.getcurrentFloor() + " Direction: " + elevator.getDirections());
    }
    public void open() {
        if (elevator.getState() == false) {
            System.out.println("Open Door # Floor " + elevator.getcurrentFloor());
            System.out.println("Close Door");
            elevator.setState(true);
        }
    }
    public void MOVE() {
        boolean fir = true;
        elevator.setState(true);
        DirectionSet();
        int aim=aimfloor;
        while (true) {
            if (queue.getInRequests().isEmpty() && queue.getOutRequests().isEmpty())
                break;
            if (!fir) {
                determineDirecion();
                isget();
                delet();
                open();
                determineDirecion();
                aim=aimfloor;
            }else outmessage();
            if (queue.getInRequests().isEmpty() && queue.getOutRequests().isEmpty())
                break;
            if (elevator.getDirections().equals("UP")) {
                while (elevator.getcurrentFloor() !=aim ) {
                    elevator.setCurrentFloor(elevator.getcurrentFloor()+1);
                    outmessage();
                    determineDirecion();
                    isget();
                    delet();
                    open();
                }
                aim=aimfloor;

            } else if (elevator.getDirections().equals("DOWN")) {
                while (elevator.getcurrentFloor() != aim) {
                    elevator.setCurrentFloor(elevator.getcurrentFloor()-1);
                    outmessage();
                    determineDirecion();
                    isget();
                    delet();
                    open();

                }
                aim=aimfloor;
            }
            fir = false;
        }
    }
}

题目集六的电梯和题目五的大差不大，但老师让我们的更加规范和看起来的确的舒服很多。

还加入了

乘客请求楼层数有误，具体为高于最高楼层数或低于最低楼层数，处理方法：程序自动忽略此类输入，继续执行

乘客请求不合理，具体为输入时出现连续的相同请求，例如<3><3><3>或者<5,DOWN><5,DOWN>，处理方法：程序自动忽略相同的多余输入，继续执行，例如<3><3><3>过滤为<3>

我本来想在原本的代码上改的但被杀死了真的不如再写一遍！

代码结构和模块化

模块化设计：学习如何将复杂的问题分解成多个模块（类），每个模块负责特定的功能。

代码复用：理解如何通过方法和类的复用提高代码的效率和可维护性。

这次的题目可以让我对代码结构和模块化 有特别细致的理解，有时候会觉得题目给出的那个代码类要求实在是不明所以毫无软用啊。但其实用起来，还是老师规定了的爽，省的自己想，但的的确确很难猜有些函数有什么用。

7-3

  

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

import static java.lang.Math.min;

/**
 * Gindama On Java Now
 * 2025/4/12 11:36
 * By The Spirit Of MF DOOM
 */
enum Direction {
    UP, DOWN, IDLE;
}

enum State {
    MOVING, STOPPED;
}

public class Main {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        String data = "";
        int minFloor, maxFloor;

        // 读取最小和最大楼层
        minFloor = input.nextInt();
        maxFloor = input.nextInt();

        // 创建请求队列和电梯
        RequestQueue queue = new RequestQueue();
        Elevator elevator = new Elevator(maxFloor, minFloor);

        // 读取输入直到遇到 "end" 或 "END"
        while (true) {
            data = input.next();

            // 检查是否是结束命令
            if (data.equalsIgnoreCase("end") || data.equalsIgnoreCase("END")) {
                break;
            }


            if (data.startsWith("<") && data.endsWith(">")) {
                String content = data.substring(1, data.length() - 1);

                if (content.contains(",")) {
                    String[] parts = content.split(",");
                    int sourceFloor = getFloor(parts[0]);
                    int destinationFloor = getFloor(parts[1]);

                    if (sourceFloor != -1 && destinationFloor != -1) {
                        Passenger passenger = new Passenger(sourceFloor, destinationFloor);
                        elevator.addExternalRequest(passenger);
                    }
                }
                // 处理内部请求（格式：<destinationFloor>）
                else {
                    int floor = getFloor(content);
                    if (floor != -1) {
                        Passenger passenger = new Passenger(null, floor);
                        elevator.addInternalRequest(passenger);
                    }
                }
            }
        }
        elevator.processRequests();
    }

    private static int getFloor(String floorStr) {
        return Integer.parseInt(floorStr);
    }


    static class Passenger {
        private Integer sourceFloor;
        private Integer destinationFloor;

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

        public Integer getSourceFloor() {
            return sourceFloor;
        }

        public void setSourceFloor(Integer sourceFloor) {
            this.sourceFloor = sourceFloor;
        }

        public Integer getDestinationFloor() {
            return destinationFloor;
        }

        public void setDestinationFloor(Integer destinationFloor) {
            this.destinationFloor = destinationFloor;
        }

        public Direction getDirection() {//确认目标方向
            if (sourceFloor == null || destinationFloor == null) {
                return null;
            }
            return (destinationFloor > sourceFloor) ? Direction.UP : Direction.DOWN;
        }
    }

    static class RequestQueue {
        private ArrayList<Passenger> inRequests = new ArrayList<>();
        private ArrayList<Passenger> outRequests = new ArrayList<>();

        public ArrayList<Passenger> getInRequests() {
            return inRequests;
        }

        public void setInRequests(ArrayList<Passenger> inRequests) {
            this.inRequests = inRequests;
        }

        public ArrayList<Passenger> getOutRequests() {
            return outRequests;
        }

        public void setOutRequests(ArrayList<Passenger> outRequests) {
            this.outRequests = outRequests;
        }

        public void addInRequest(Passenger passenger) {
            inRequests.add(passenger);
        }

        public void addOUtRequest(Passenger passenger) {
            outRequests.add(passenger);
        }

        public void removeInRequst(Passenger passenger) {
            inRequests.remove(passenger);
        }

        public void removeOutRequst(Passenger passenger) {
            outRequests.remove(passenger);
        }


    }

    static class Elevator {
        // 包含电梯的最大楼层数、最小楼层数（默认为1层）当前楼层、运行方向、运行状态，
        // 以及电梯内部乘客的请求队列和电梯外部楼层乘客的请求队列，其中，电梯外部请求队列需要区分上行和下行。
        private int MaxFloor;
        private int MinFloor = 1;
        private Direction Directions; // 方向
        private boolean state; // 运动状态
        private int currentFloor = 1;
        private RequestQueue queue;

        public Elevator() {
        }

        public Elevator(int maxFloor, int minFloor) {
            MaxFloor = maxFloor;
            MinFloor = minFloor;
            Directions = Direction.UP;
            currentFloor = 1;
            queue = new RequestQueue(); // 初始化queue
        }

        public int getMaxFloor() {
            return MaxFloor;
        }

        public void setMaxFloor(int maxFloor) {
            MaxFloor = maxFloor;
        }

        public int getMinFloor() {
            return MinFloor;
        }

        public void setMinFloor(int minFloor) {
            MinFloor = minFloor;
        }

        public Direction getDirections() {
            return Directions;
        }

        public void setDirections(Direction directions) {
            Directions = directions;
        }

        public boolean getState() {
            return state;
        }

        public void setState(boolean state) {
            this.state = state;
        }

        public int getcurrentFloor() {
            return currentFloor;
        }

        public void setCurrentFloor(int currentFloor) {
            this.currentFloor = currentFloor;
        }

        public boolean isvalidFloor(int floor) {
            if (floor < MinFloor || floor > MaxFloor) {
                return false;
            }
            return true;
        }

        public void addInternalRequest(Passenger passenger) {
            if (passenger.getDestinationFloor() < MinFloor || passenger.getDestinationFloor() > MaxFloor) {
                return;
            }
            if (!queue.getInRequests().isEmpty() && queue.getInRequests().get(queue.inRequests.size() - 1).getDestinationFloor().equals(passenger.getDestinationFloor())) {
                return;
            }
            queue.addInRequest(passenger);
        }

        public void addExternalRequest(Passenger passenger) {
            if (passenger.getSourceFloor() == null || passenger.getDestinationFloor() == null || passenger.getSourceFloor() < MinFloor || passenger.getSourceFloor() > MaxFloor || passenger.getDestinationFloor() < MinFloor || passenger.getDestinationFloor() > MaxFloor) {
                return;
            }
            if (!queue.getOutRequests().isEmpty()) {
                Passenger lastRequest = queue.getOutRequests().get(queue.outRequests.size() - 1);
                if (lastRequest.getSourceFloor().equals(passenger.getSourceFloor()) && lastRequest.getDestinationFloor().equals(passenger.getDestinationFloor())) {
                    return;
                }
            }
            queue.addOUtRequest(passenger);
        }

        public void processRequests() {
            Controller controller = new Controller(this, queue);
            controller.processRequests();
        }


        public void setState(State state) {
        }

        public void setQueue(RequestQueue queue) {
        }
    }

    static class Controller {
        private Elevator elevator;
        private RequestQueue queue;

        public Controller() {
        }

        public Controller(Elevator elevator, RequestQueue queue) {
            this.elevator = elevator;
            this.queue = queue;
        }

        public Elevator getElevator() {
            return elevator;
        }

        public void setElevator(Elevator elevator) {
            this.elevator = elevator;
        }

        public RequestQueue getQueue() {
            return queue;
        }

        public void setQueue(RequestQueue queue) {
            this.queue = queue;
        }

        public void processRequests() {
            determineDirection();
            System.out.println("Current Floor: " + elevator.getcurrentFloor() + " Direction: " + elevator.getDirections());

            while (!queue.getInRequests().isEmpty() || !queue.getOutRequests().isEmpty()) {
                int targetFloor = getNextFloor();
                move(targetFloor);

                if (elevator.getcurrentFloor() == targetFloor) {
                    if (shouldStop(elevator.getcurrentFloor())) {
                        openDoors();
                        removeRequests(elevator.getcurrentFloor());
                    }
                    determineDirection();
                }
            }

        }

        private void determineDirection() {
            if (elevator.getDirections() == Direction.IDLE) {
                if (!queue.getInRequests().isEmpty()) {
                    if (queue.getInRequests().get(0).getDestinationFloor() > elevator.getcurrentFloor()) {
                        elevator.setDirections(Direction.UP);
                    } else if (queue.getInRequests().get(0).getDestinationFloor() < elevator.getcurrentFloor()) {
                        elevator.setDirections(Direction.DOWN);
                    }
                } else if (!queue.getOutRequests().isEmpty()) {
                    if (queue.getOutRequests().get(0).getSourceFloor() > elevator.getcurrentFloor()) {
                        elevator.setDirections(Direction.UP);
                    } else if (queue.getOutRequests().get(0).getSourceFloor() < elevator.getcurrentFloor()) {
                        elevator.setDirections(Direction.DOWN);
                    }
                } else {
                    elevator.setDirections(Direction.IDLE);
                }
            } else if (elevator.getDirections() == Direction.UP) {
                boolean hasInternal = false;
                boolean hasExternal = false;
                if (!queue.getInRequests().isEmpty()) {
                    if (queue.getInRequests().get(0).getDestinationFloor() > elevator.getcurrentFloor()) {
                        hasInternal = true;
                    }
                }
                if (!queue.getOutRequests().isEmpty()) {
                    if (queue.getOutRequests().get(0).getSourceFloor() > elevator.getcurrentFloor()) {
                        hasExternal = true;
                    }
                }
                if (!hasInternal && !hasExternal) {
                    elevator.setDirections(Direction.DOWN);
                }
            } else if (elevator.getDirections() == Direction.DOWN) {
                boolean hasInternal = false;
                boolean hasExternal = false;
                if (!queue.getInRequests().isEmpty()) {
                    if (queue.getInRequests().get(0).getDestinationFloor() < elevator.getcurrentFloor()) {
                        hasInternal = true;
                    }
                }
                if (!queue.getOutRequests().isEmpty()) {
                    if (queue.getOutRequests().get(0).getSourceFloor() < elevator.getcurrentFloor()) {
                        hasExternal = true;
                    }
                }
                if (!hasInternal && !hasExternal) {
                    elevator.setDirections(Direction.UP);
                }
            }
        }

        private void move(int targetFloor) {
            if (elevator.getcurrentFloor() < targetFloor) {
                elevator.setDirections(Direction.UP);
                for (int i = elevator.getcurrentFloor() + 1; i <= targetFloor; i++) {
                    elevator.setCurrentFloor(i);
                    System.out.println("Current Floor: " + i + " Direction: " + elevator.getDirections());
                }
            } else if (elevator.getcurrentFloor() > targetFloor) {
                elevator.setDirections(Direction.DOWN);
                for (int i = elevator.getcurrentFloor() - 1; i >= targetFloor; i--) {
                    elevator.setCurrentFloor(i);
                    System.out.println("Current Floor: " + i + " Direction: " + elevator.getDirections());
                }
            }
        }

        private boolean shouldStop(int floor) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getDestinationFloor() == floor) {
                    elevator.setState(State.STOPPED);
                    return true;
                }
            }
            if (!queue.getOutRequests().isEmpty()) {
                Passenger temp = queue.getOutRequests().get(0);
                if (temp.getDirection() == elevator.getDirections() && temp.getSourceFloor() == floor) {
                    elevator.setState(State.STOPPED);
                    return true;
                }
            }
            return false;
        }

        private int getNextFloor() {
            if (queue.getInRequests().isEmpty() && queue.getOutRequests().isEmpty()) {
                return elevator.getcurrentFloor();
            }

            int internalFloor = Integer.MAX_VALUE;
            int externalFloor = Integer.MAX_VALUE;

            if (!queue.getInRequests().isEmpty()) {
                internalFloor = queue.getInRequests().get(0).getDestinationFloor();
            }

            if (!queue.getOutRequests().isEmpty()) {
                externalFloor = queue.getOutRequests().get(0).getSourceFloor();
            }

            if (elevator.getDirections() == Direction.UP) {
                if (internalFloor > elevator.getcurrentFloor() && externalFloor > elevator.getcurrentFloor()) {
                    return min(internalFloor, externalFloor);
                } else if (internalFloor > elevator.getcurrentFloor()) {
                    return internalFloor;
                } else if (externalFloor > elevator.getcurrentFloor()) {
                    return externalFloor;
                }
            } else if (elevator.getDirections() == Direction.DOWN) {
                if (internalFloor < elevator.getcurrentFloor() && externalFloor < elevator.getcurrentFloor()) {
                    return Math.max(internalFloor, externalFloor);
                } else if (internalFloor < elevator.getcurrentFloor()) {
                    return internalFloor;
                } else if (externalFloor < elevator.getcurrentFloor()) {
                    return externalFloor;
                }
            }

            return elevator.getcurrentFloor();
        }

        private void openDoors() {
            System.out.println("Open Door # Floor " + elevator.getcurrentFloor());
            System.out.println("Close Door");
        }

        private void removeRequests(int currentFloor) {
            if (!queue.getInRequests().isEmpty()) {
                if (queue.getInRequests().get(0).getDestinationFloor() == currentFloor) {
                    queue.getInRequests().remove(0);
                }
            }
            if (!queue.getOutRequests().isEmpty()) {
                Passenger firstExternalRequest = queue.getOutRequests().get(0);
                if (firstExternalRequest.getSourceFloor() == currentFloor && firstExternalRequest.getDirection() == elevator.getDirections()) {
                    queue.getInRequests().add(new Passenger(currentFloor, firstExternalRequest.getDestinationFloor()));
                    queue.getOutRequests().remove(0);
                }
            }
        }

        private int getClosest(int a, int b) {
            return min(a, b);
        }


    }


}

从题目七的这次作业引入了乘客的概念。

你知道吗！我一开始！！我真心的以为！！！这个题目我想不出来了。真的。原来题目有提示啊！

乘客请求输入变动情况：外部请求由之前的<请求楼层数,请求方向>修改为<请求源楼层，请求目的楼层>
对于外部请求，当电梯处理该请求之后（该请求出队），要将<请求源楼层，请求目的楼层>中的请求目的楼层加入到请求内部队列(加到队尾）

不是哥们我真的没看到！！！我真的没看到！！！！！！我去你都不知道我把这个题目想得有多么的复杂这个题目耗费了我多少的心血！我真的是蠢笨如猪。我当时真心以为能不用AI！不去讨论想到的人真是聪明绝顶

先将方法解释一下

主类（Main）

功能：程序的入口点，用于初始化电梯系统并处理用户输入。
输入读取：从控制台读取最小和最大楼层，以及用户的请求。
请求处理：根据用户输入创建内部或外部请求，并将其添加到请求队列中。
电梯调度：创建电梯对象并调用其方法来处理请求队列中的请求。

枚举类型（Direction 和 State）

Direction：表示电梯的移动方向，有向上（UP）、向下（DOWN）和静止（IDLE）三种状态。
State：表示电梯的运行状态，有移动中（MOVING）和停止（STOPPED）两种状态。

乘客类（Passenger）

属性：包含乘客的起点楼层（sourceFloor）和目标楼层（destinationFloor）。
方法：提供获取和设置这些属性的方法，以及计算乘客移动方向的方法。

请求队列类（RequestQueue）

功能：管理电梯的内部和外部请求队列。
内部请求：乘客在电梯内部按下的楼层按钮。
外部请求：乘客在楼层按下的电梯按钮，包含上行和下行请求。
方法：提供添加和移除请求的方法。

电梯类（Elevator）

属性：包含电梯的最大楼层、最小楼层、当前楼层、方向、状态以及请求队列。
方法：提供处理请求的方法，以及获取和设置电梯属性的方法。
请求处理：根据乘客请求更新电梯的内部和外部请求队列。

控制器类（Controller）

功能：负责电梯的调度逻辑，根据请求队列和电梯状态来控制电梯的移动。
方向确定：根据请求队列中的第一个请求确定电梯的初始方向。
移动模拟：根据目标楼层移动电梯，并在移动过程中输出当前楼层和方向。
停止逻辑：判断电梯是否需要在当前楼层停止以响应请求。
请求处理：在电梯停止时，处理当前楼层的请求，并更新请求队列。
电梯门控制：模拟电梯门的打开和关闭

Main 类

main 方法：程序的入口点。读取用户输入，初始化电梯系统，并调用电梯的 processRequests 方法来处理请求。

`Passenger` 类

构造方法：初始化乘客的起点楼层和目标楼层。
getSourceFloor 和 getDestinationFloor 方法：返回乘客的起点楼层和目标楼层。
setSourceFloor 和 setDestinationFloor 方法：设置乘客的起点楼层和目标楼层。
getDirection 方法：根据乘客的起点楼层和目标楼层，计算乘客的移动方向（向上、向下）。

`RequestQueue` 类

addInRequest 和 addOUtRequest 方法：将内部请求和外部请求添加到请求队列中。
removeInRequst 和 removeOutRequst 方法：从请求队列中移除内部请求和外部请求。
getInRequests 和 getOutRequests 方法：返回内部请求和外部请求队列。

`Elevator` 类

构造方法：初始化电梯的最大楼层、最小楼层、当前楼层、方向和状态。
addInternalRequest 方法：将内部请求添加到电梯的请求队列中。
addExternalRequest 方法：将外部请求添加到电梯的请求队列中。
processRequests 方法：调用控制器来处理请求队列中的请求。
get 和 set 方法：获取和设置电梯的属性，如当前楼层、方向、状态等。

`Controller` 类

构造方法：初始化控制器，关联电梯和请求队列。
processRequests 方法：处理请求队列中的请求，控制电梯的移动和停止。
determineDirection 方法：根据请求队列确定电梯的移动方向。
move 方法：根据目标楼层移动电梯，并输出当前楼层和方向。
shouldStop 方法：判断电梯是否需要在当前楼层停止以响应请求。
getNextFloor 方法：根据电梯的方向和请求队列，确定电梯的下一目标楼层。
openDoors 方法：模拟电梯门的打开和关闭。
removeRequests 方法：在电梯停止时，移除已处理的请求。
getClosest 方法：辅助方法，用于确定最近的楼层。

又到了我最喜欢的画图时间

这个就是 <1><2,4><3><3,1>的

我是先在输入进去的时候就开始判断！

这个就是目标！你看这不就和题目集之前一模一样吗！

当我们按照之前的逻辑到达了乘客的楼层我们就将他的目标楼层放到外部请求最后。

如图所示这时候有人就要问了主播主播？ 我能不能在一开始读入的时候就将其判断出来并将他放到外部请求最后呢？？？

不可以！！ 因为我一开始就是这样写的哈。

来来来你告诉我

我要是要是输入 <2> <1,3> <4>

你输入就判断你告诉我 我的外部该是 2 3 4还是 2 4 3呢？？

你没有顺序啊所以我觉得我这样是最完美的计划

踩坑心得：

1.代码就别重构了我是重构不来

重写代码：就像给旧房子重新打地基，虽然麻烦，但有时候能让它稳如泰山。

重构代码：就像给旧房子换个新屋顶，虽然能解决问题，但有时候房子本身已经摇摇欲坠了。

所以，代码尽量不要重构而是重写，就是说，有时候与其费力修补一个破旧的系统，不如直接推倒重建，这样可以确保代码的质量和可维护性，虽然这可能需要更多的精力和时间，但从长远来看，它能带来更稳定和高效的结果。

2.读题很重要啊

不认真读题可能会让你在完成任务后发现需要大量返工。这就像在建房子时没看清楚设计图，结果建了一半才发现你造的是一个厕所而不是一个卧室。认真读题可以帮助你避免这种“返工”的烦恼。能够帮助你避免那些让你拍脑袋的“低级错误”。你可能会想，“我直接动手做，再回来读题也不迟。” 但事实上，误读题目可能会让你浪费大量时间。认真读题不仅仅是为了避免错误，更是为了提高效率、增强自信并确保任务顺利完成。就像在航海中，你需要仔细研究航海图，才能确保船只航行在正确的航线上。

3.调试很爽啊F6我按不停的

调试就像是在代码里挖地雷，你永远不知道下一行代码会不会让你中招。通过调试，你可以发现那些隐藏的错误。可以帮助你理解代码的实际执行流程，避免你在脑海里无休止地模拟程序运行。这样可以保存你的脑细胞，让你有更多的精力去解决真正重要的问题。帮助你更好地理解代码的逻辑和潜在问题。每一次调试都是一次提升编程技能的机会，让你在未来的开发中更加得心应手。调试是编程过程中不可或缺的一部分，它不仅有助于发现和解决问题，还能提升你的编程技能和信心。就像医生需要听诊器来诊断病人的心跳一样，程序员需要调试工具来检查代码的状况。

总结：

最开始接触电梯编程的时候，我常常感到头晕目眩。语法错误、逻辑错误，各种问题接踵而至，让我一度怀疑自己是不是选错了路，我是不是不适合这个专业，我每天都在和编译器斗智斗勇，每次看到屏幕上冒出的错误提示，我都想直接把键盘扔了。但你知道吗？每当我成功运行一段代码，那种成就感就像是在黑暗中找到了一丝光亮，让我觉得这一切努力都是值得的。编程不仅是技术的较量，更是耐心和细心的比拼。每一次遇到问题并解决它，练习调试技能，找几个细枝末节的难以发现的错误，有一次，我在处理电梯的方向逻辑时，怎么也找不到问题所在。于是，我一步步地设置断点，观察变量的变化，最终发现是一个小小的逻辑判断错误。那种豁然开朗的感觉，真的让人上瘾。在这个过程中，我也逐渐领悟到编程的精髓不在于写出多么炫技的代码，而在于写出高效、可读、易维护的代码。并且我真心认为和同学交流思想是重要的。比抄代码有用多了，定期和同学们交流学习心得。我们互相分享遇到的问题和解决方法，有时候还会一起debug。我真心的认为这样的学习很能引发我们的思考！当然我的代码绝对不算完美，甚至碰不上完美，简直就是烂，而且算法的优化能力有待提高，编写的代码在处理大规模数据或复杂逻辑时，效率可能较低，需要学习更多知识，优化代码性能。此外，设计模式的应用也需要深入研究，以提高代码的可维护性、可扩展性和复用性。

我把我想说的说完了我相信没人会看这个Blog 除了我希望这个对你有帮助谢谢老师谢谢java 谢谢中国

posted @ 2025-04-18 19:34 Gindama 阅读(107) 评论(2) 收藏举报

刷新页面返回顶部

Gindama7013

题目集5~7的总结性Blog

04/18/2025 19:06:22

前言：

分析代码和心得：

`determineDirecion()`

`DirectionSet()`

`isget()`

`MOVE()`

代码结构和模块化

主类（Main）

枚举类型（Direction 和 State）

乘客类（Passenger）

请求队列类（RequestQueue）

电梯类（Elevator）

控制器类（Controller）

`Passenger` 类

`RequestQueue` 类

`Elevator` 类

`Controller` 类

踩坑心得：

总结：

公告

Gindama7013

题目集5~7的总结性Blog

04/18/2025 19:06:22

前言：

分析代码和心得：

determineDirecion()

DirectionSet()

isget()

MOVE()

代码结构和模块化

主类（Main）

枚举类型（Direction 和 State）

乘客类（Passenger）

请求队列类（RequestQueue）

电梯类（Elevator）

控制器类（Controller）

Passenger 类

RequestQueue 类

Elevator 类

Controller 类

踩坑心得：

总结：

公告

`determineDirecion()`

`DirectionSet()`

`isget()`

`MOVE()`

`Passenger` 类

`RequestQueue` 类

`Elevator` 类

`Controller` 类