Java 实现电梯逻辑

一、实现结果说明

这里首先说明实现结果：

1、已实现：

实现电梯的移动逻辑。
实现了电梯外部的每个楼层的上下按钮。
实现了电梯运行的同时添加新楼层。

2、未实现：

没有实现电梯内部的按钮。
没有实现多个电梯协同运行。
没有实现电梯开关门时的逻辑。

二、电梯运行的情况

当电梯向上移动时，会一直运行至发出请求的所有楼层中最高的楼层。
向下移动时，会一直运行至发生请求的所有楼层中最低的楼层。
在电梯运行过程中，如果有用户点击了某一层的按钮，会根据该层的按钮与当前电梯所在的层数和电梯要去的层数相比较，以及判断电梯的运行方向，来确定下一步去往的楼层。

三、实现说明

该代码实现使用 Java 编写，使用多线程来分析处理电梯的移动，以及各个楼层的按钮点击处理。

当然，没有展示的页面，Java 编写可视化页面还是相当吃翔的。采用控制台输出的方式来告诉开发者现在电梯所在的楼层。

实现代码中目前一共包含七个类（多数属于非严格的单例对象）：

Lift.java：负责电梯的移动，从任务列表中取得任务，并判断电梯应该运行的方向。
LayerRequest.java ：这个类是定义的一个数据结构，用来保存每个楼层的请求。负责处理电梯获取或者删除任务的请求，以及各个楼层召唤电梯的请求。
LayerList.java：该类保存着每个楼层。是一个继承了 ArrayList 的类。
Layer.java：该类表示的是单个楼层，存储着某个楼层的信息。
MoveDirection.java：电梯的移动方向，电梯的移动方向有三种：UP、DOWN、STOP。
Client.java：客户端处理类，电梯与外界交互就靠这一个类，可以使用该类向电梯发送上升或者下降的请求。同时该类管理着一个线程池。
Test.java：测试类。

四、部分代码解析

如果要查看源代码，可以从 CSDN 上下载 ZIP 文件 CSDN ------ Java 实现电梯逻辑。

同时也提供了 GitHub 项目地址：GitHub ------ Java 实现电梯逻辑。

1、Lift.java 核心代码

java 复制代码

/**
     * 向上移动电梯
     */
    private void moveUp() {
        int currentLayerNumber = this.getCurrentLayer().getLayerNumber();
        int targetLayerNumber;
        while (currentLayerNumber < (targetLayerNumber = this.getTargetLayer().getLayerNumber())) {
            this.moving();
            Layer layer = this.layerList.get(currentLayerNumber);
            this.setCurrentLayer(layer);
            currentLayerNumber++;
            if (currentLayerNumber != targetLayerNumber) {
                this.passLayer(layer);
            }
        }
        this.reachTargetLayer();
    }

    /**
     * 向下移动电梯
     */
    private void moveDown() {
        int currentLayerNumber = this.getCurrentLayer().getLayerNumber();
        int targetLayerNumber;
        while (currentLayerNumber > (targetLayerNumber = this.getTargetLayer().getLayerNumber())) {
            this.moving();
            // 这里减二是因为：
            // 需要通过索引获取楼层, getLayerNumber() 对索引进行了加一, 需要减一获得索引,
            // 而这里是电梯下降, 需要获取下一个楼层的索引, 所以还要再减一
            Layer layer = this.layerList.get(currentLayerNumber - 2);
            this.setCurrentLayer(layer);
            currentLayerNumber--;
            if (currentLayerNumber != targetLayerNumber) {
                this.passLayer(layer);
            }
        }
        this.reachTargetLayer();
    }

    /**
     * 移动电梯到目标楼层
     */
    private void move(int diff) {
        if (diff > 0) {
            moveDown();
        } else {
            moveUp();
        }
    }

    /**
     * 电梯运行, 主要负责电梯的移动
     */
    void run() {
        while (this.runnable()) {
            try {
                this.setUsing(this.layerRequest.hasTask());
                if (!this.isUsing()) {
                    continue;
                }
                // 电梯有任务才会执行核心函数
                this.runCore();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 电梯是否可运行
     *
     * @return 可运行返回 true
     */
    private boolean runnable() {
        return !isFault();
    }

    /**
     * 电梯运行核心 (我是这样起名的, 它配不配这个名字我就不知道了)<br/>
     * 此时电梯一定处于 stop 状态
     */
    private void runCore() {
        Layer layer;
        LayerRequest layerRequest = this.layerRequest;
        int diff;
        int currentLayerNumber = this.getCurrentLayer().getLayerNumber();
        int targetLayerNumber = this.getTargetLayer().getLayerNumber();

        // 根据 当前楼层 与 目标楼层 的相对位置来设置电梯移动方向
        if ((diff = currentLayerNumber - targetLayerNumber) < 0) {
            layer = layerRequest.getLayer();
            if (layer != null) {
                this.setCurrentMoveDirection(MoveDirection.UP);
            } else {
                this.setCurrentMoveDirection(MoveDirection.DOWN);
            }
        } else if ((diff = currentLayerNumber - targetLayerNumber) > 0) {
            layer = layerRequest.getLayer();
            if (layer != null) {
                this.setCurrentMoveDirection(MoveDirection.DOWN);
            } else {
                this.setCurrentMoveDirection(MoveDirection.UP);
            }
        } else {
            return;
        }

        if (this.checkLayer(layer)) {
            this.setTargetLayer(layer);
            this.move(diff);
        }
    }

    /**
     * 检查楼层所属的区间, 下面是 layer 楼层所在的不同区间的所有的返回结果: <br/>
     * 一. [ (layer: -1) 低楼层 -- (layer: 0) --> 高楼层 (layer: 1) ] <br/>
     * 二. [ (layer: -1) 高楼层 -- (layer: 0) --> 低楼层 (layer: 1) ] <br/>
     * 三. 电梯处于 stop 状态时若电梯处于 stop 状态, 返回 layer 与 currentLayer 的楼层差值
     *
     * @param layer 要检查的楼层
     * @return 返回数字, 表示 layer 楼层所属的区间
     */
    int checkLayerInRange(Layer layer) {
        Layer currentLayer = this.getCurrentLayer();
        Layer targetLayer = this.getTargetLayer();
        int currentLayerNumber = currentLayer.getLayerNumber();
        int targetLayerNumber = targetLayer.getLayerNumber();

        int layerNumber = layer.getLayerNumber();

        // 上升时, 返回值取决于楼层 layer 所在的区间: [ (layer: -1) 低楼层 -- (layer: 0) --> 高楼层 (layer: 1) ]
        if (isMoveUp()) {
            if (layerNumber < currentLayerNumber) {
                return -1;
            } else if (targetLayerNumber < layerNumber) {
                return 1;
            } else {
                return 0;
            }
        }
        // 下降时, 返回值取决于 layer 所在的区间: [ (layer: -1) 高楼层 -- (layer: 0) --> 低楼层 (layer: 1) ]
        else if (isMoveDown()) {
            if (layerNumber < targetLayerNumber) {
                return 1;
            } else if (layerNumber > currentLayerNumber) {
                return -1;
            } else {
                return 0;
            }
        }
        // 若电梯处于 stop 状态, 返回 layerNumber 与 currentLayerNumber 的差值
        else {
            return layerNumber - currentLayerNumber;
        }
    }

2、LiftRequest.java 核心代码

java 复制代码

void removeUpLayer() {
        this.removeLayer(this.nextUpList, this.nextDownList, MoveDirection.UP);
    }

    void removeDownLayer() {
        this.removeLayer(this.nextDownList, this.nextUpList, MoveDirection.DOWN);
    }

    /**
     * 电梯到达目标楼层时移除楼层, 从 usingList 中移除 <br/>
     * 当 usingList 中没有楼层时, 则设置 freeList 的第一个元素为 {@link Lift#targetLayer}, freeList 将成为 usingList<br/>
     *
     * @param nextUsingList 下一执行阶段要执行的任务
     * @param nextFreeList  下一执行阶段要执行的任务
     * @param moveDirection 当前电梯的运行状态
     */
    private void removeLayer(List<Layer> nextUsingList, List<Layer> nextFreeList,
                             MoveDirection moveDirection) {
        Lift lift = this.lift;
        List<Layer> taskList = this.taskList;

        // 当前任务执行完成, 将其移除
        removeFirst();

        // 移除后如果任务列表不为空, 就将列表第一个楼层设为目标楼层
        if (!taskList.isEmpty()) {
            lift.setTargetLayer(getFirst());
            return;
        }

        // 这段代码在下面的情况下生效 (电梯发生转向时):
        // 例如: 电梯从第一层移动到第七层, 在电梯到达第五层时, 此时在第三层按下向下的按钮, 将会添加到 nextFreeList 集合中
        if (!nextFreeList.isEmpty()) {
            taskList.addAll(nextFreeList);
            // 根据不同的移动状态排序
            if (MoveDirection.isMoveUp(moveDirection)) {
                this.reserveSort();
            } else if (MoveDirection.isMoveDown(moveDirection)) {
                this.sort();
            }
            lift.setTargetLayer(getFirst());
            nextFreeList.clear();
        }

        // 如果电梯反向运行列表没有元素 (nextFreeList 为空, empty), 就执行同向的任务列表
        // 例如: 电梯要从第一层移动到第七层, 并且电梯已经移动到第四层, 此时点击第一层的上升按钮和第三层的上升按钮,
        // 将会添加到 nextUsingList 集合中
        // 电梯移动过程: (1): 1 --- 上升 ---> 7  (2): 7 --- 下降 ---> 1  (3): 1 --- 上升 ---> 3
        if (taskList.isEmpty() && !nextUsingList.isEmpty()) {
            taskList.addAll(nextUsingList);
            if (MoveDirection.isMoveUp(moveDirection)) {
                this.sort();
            } else if (MoveDirection.isMoveDown(moveDirection)) {
                this.reserveSort();
            }
            lift.setTargetLayer(getFirst());
            nextUsingList.clear();
        }
    }

    /**
     * 添加楼层
     * @param layer 要添加的楼层
     * @param moveDirection 要去往的方向
     */
    void addLayer(Layer layer, MoveDirection moveDirection) {
        if (!this.taskList.contains(layer)) {
            Lift lift = this.lift;
            if (lift.getCurrentLayer().equals(layer)) {
                this.alreadyLocated(layer);
                return;
            }
            lift.setTargetLayerIfNull(layer);
            int result = lift.checkLayerInRange(layer);
            // 如果电梯处于停止状态
            if (lift.isMoveStop()) {
                if (result > 0) {
                    this.addUpLayerWithSort(layer);
                    lift.setCurrentMoveDirection(MoveDirection.UP);
                } else if (result < 0) {
                    this.addDownLayerWithSort(layer);
                    lift.setCurrentMoveDirection(MoveDirection.DOWN);
                }
                lift.setTargetLayer(layer);
                return;
            }
            // 根据按钮点击的是上升还是下降来调用
            if (MoveDirection.isMoveUp(moveDirection)) {
                this.addUpLayer(result, layer);
            } else {
                this.addDownLayer(result, layer);
            }
        }
    }

    /**
     * 添加要上楼的楼层
     *
     * @param result result
     * @param layer 要添加的楼层
     */
    private void addUpLayer(int result, Layer layer) {
        Lift lift = this.lift;
        if (lift.isMoveUp()) {
            if (result == 0) {
                lift.setTargetLayer(layer);
                this.addUpLayerWithSort(layer);
            } else if (result == 1) {
                this.addUpLayerWithSort(layer);
            } else if (result == -1) {
                this.addLayerIfNotExist(this.nextUpList, layer);
            }
        } else if (lift.isMoveDown()) {
            this.addLayerIfNotExist(this.nextUpList, layer);
        }
    }

    /**
     * 添加要下楼的楼层
     *
     * @param layer 要添加的楼层
     */
    void addDownLayer(int result, Layer layer) {
        Lift lift = this.lift;
        if (lift.isMoveDown()) {
            if (result == 0) {
                lift.setTargetLayer(layer);
                this.addDownLayerWithSort(layer);
            } else if (result == 1) {
                this.addDownLayerWithSort(layer);
            } else if (result == -1) {
                this.addLayerIfNotExist(this.nextDownList, layer);
            }
        } else if (lift.isMoveUp()) {
            this.addLayerIfNotExist(this.nextDownList, layer);
        }
    }

五、有话说

有兴趣的小伙伴可以自己写一个类似的程序，或者在此基础上做修改、加上新的处理逻辑，代码如有瑕疵，敬请见谅！