Java电梯模拟升级版

news2024/10/6 12:30:51

Java电梯模拟升级版

文章目录

  • Java电梯模拟升级版
  • 前言
  • 一、UML类图
  • 二、代码
  • 三、测试

前言

在上一版的基础上进行升级，楼层采用享元模式进行升级，并对楼层对象进一步抽象

一、UML类图

在这里插入图片描述

二、代码

电梯调度器抽象类

package cn.xx.evevator;

import java.util.*;


public abstract class AbstarctDispatcher {



    protected  AbstractEvevator abstractEvevator;


    public void setAbstractEvevator(AbstractEvevator abstractEvevator) {
        this.abstractEvevator = abstractEvevator;
    }

    protected abstract void pressFloor(Integer[] floors);

    protected abstract Floor getFloor(Integer floor);

    public abstract void run(int floor,Status status);

    public abstract void changeTargetMax(Integer floor);

}

调度器继承类

package cn.xx.evevator;

import java.util.Arrays;

public class Dispatcher extends AbstarctDispatcher{


    @Override
    protected void pressFloor(Integer[] floors) {
        if (floors!=null && floors.length>0){
            this.abstractEvevator.status.handler(this,floors);
        }
    }

    @Override
    protected Floor getFloor(Integer floor) {
        return this.abstractEvevator.instance.getFloor(floor);
    }



    @Override
    public synchronized void run(int floor, Status status) {
        abstractEvevator.run(floor,status);
    }

    @Override
    public void changeTargetMax(Integer floor) {
        if (abstractEvevator.targetFloorMax<floor){
            abstractEvevator.targetFloorMax = floor;
        }

    }

}

电梯抽象类

package cn.xx.evevator;

public abstract class AbstractEvevator {
    public static final Integer FLOOR_TOTAL = 11;

    protected final AbstarctDispatcher abstarctDispatcher;
    protected final FloorFactory instance;
    protected  Status status = StatusCommon.stopStatus;
    protected static Integer targetFloorMax = 1;
    protected static Integer targetFloorMin = 1;
    protected Integer currentFloor = 11;

    protected AbstractEvevator(AbstarctDispatcher abstarctDispatcher) {
        this.abstarctDispatcher = abstarctDispatcher;
        this.instance = FloorFactory.getInstance();
    }

    abstract void run(int floor,Status status);

    abstract void up();

    abstract void down();

    abstract void openDoor(int floor);



}

电梯继承类

package cn.xx.evevator;

public class Evevator extends AbstractEvevator{


    protected Evevator(AbstarctDispatcher abstarctDispatcher ) {
        super(abstarctDispatcher);
    }

    @Override
      void run(int floor, Status status) {
        if (floor>this.targetFloorMax){
            this.targetFloorMax = floor;
        }
        if (this.status.NAME.equals(StatusCommon.stopStatus.NAME)){
            if (this.currentFloor==floor){
                this.openDoor(floor);
                this.status = status;
            }
            if (this.currentFloor<floor){
                this.status = StatusCommon.upstatus;
                this.up();
            }
            if (this.currentFloor>floor){
                this.status = StatusCommon.downStatus;
                this.down();
            }
        }
    }

    @Override
    void up()  {
        if (targetFloorMax==this.currentFloor){
            openDoor(targetFloorMax);
        }else {
            while(this.currentFloor<targetFloorMax){
                System.out.println(Thread.currentThread().getName()+"电梯正在上升中，目前在" + this.currentFloor+"层,目标："+targetFloorMax);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Floor floor1 = instance.getFloor(this.currentFloor);
                if (floor1.isOpen){
                    openDoor(this.currentFloor);
                    floor1.isOpen=false;
                }
                if (floor1.upKey) {
                    floor1.notifyPersonLiftHere();
                }
                this.currentFloor++;
            }
        }
    }




    @Override
    void down() {
        if (targetFloorMin==this.currentFloor){
            openDoor(targetFloorMin);
        }else {
            while(this.currentFloor>targetFloorMin){
                System.out.println(Thread.currentThread().getName()+"电梯正在下降中，目前在" + this.currentFloor+"层,目标："+this.currentFloor);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Floor floor1 = instance.getFloor(this.currentFloor);
                if (floor1.isOpen){
                    openDoor(this.currentFloor);
                    floor1.isOpen=false;
                }
                if (floor1.downKey) {
                    floor1.notifyPersonLiftHere();
                }
                this.currentFloor--;
            }
        }
    }


    @Override
    void openDoor(int floor) {
        System.out.println(floor+"层开门中");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


}

楼层工厂

import java.util.HashMap;

public class FloorFactory {
    private final HashMap<Integer, Floor> map = new HashMap<>();
    private static AbstarctDispatcher abstractDispatcher = Context.getDispatcher();
    private FloorFactory(){
        for (int i = 1; i <= AbstractEvevator.FLOOR_TOTAL ; i++) {
            map.put(i,new Floor(i,abstractDispatcher));
        }
    }
    private final static FloorFactory floorFactory = new FloorFactory();
    public static FloorFactory getInstance(){
        return floorFactory;
    }
    public Floor getFloor(Integer floor){
        return map.get(floor);
    }
}

楼层抽象类

public abstract class AbstractFloor {

    protected Boolean upKey = false;
    protected Boolean downKey = false;
    protected Boolean isOpen = false;
    protected final int currentFloor;
    protected Status status;
    protected AbstarctDispatcher abstarctDispatcher;
    protected LinkedHashSet<Person> personList = new LinkedHashSet<>();
    protected AbstractFloor(int currentFloor, AbstarctDispatcher abstractDispatcher) {
        this.currentFloor = currentFloor;
        this.abstarctDispatcher = abstractDispatcher;
    }

    protected abstract void pressFrom(Person person);

    protected abstract void notifyPersonLiftHere();




}

楼层继承类

public class Floor extends AbstractFloor{

    protected Floor(int currentFloor, AbstarctDispatcher abstractDispatcher) {
        super(currentFloor,abstractDispatcher);
    }

    @Override
    protected void pressFrom(Person person) {
        person.status.press(this);
        LinkedHashSet<Person> personList = this.personList;
        if (!personList.contains(person)){
            personList.add(person);
        }
        abstarctDispatcher.run(currentFloor,person.status);
    }


    @Override
    protected void notifyPersonLiftHere() {
        LinkedHashSet<Person> people = this.personList;
        if (people!=null && people.size()>0){
            for (Person person1 : people) {
                if (person1.status.NAME.equals(person1.abstarctDispatcher.abstractEvevator.status.NAME)) {
                    person1.elevatorIsHere(currentFloor);
                }

            }
        }
    }


}

抽象状态类

package cn.xx.evevator;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;

public abstract class  Status{

    public final String NAME;

    protected Status(String name) {
        NAME = name;
    }



    abstract void handler(AbstarctDispatcher abstarctDispatcher,Integer[] floors);

    public abstract void press(Floor floor);

}

上升状态

package cn.xx.evevator;

public class UpStatus extends Status{
    
    public UpStatus(String name) {
        super(name);
    }
    
    @Override
    void handler(AbstarctDispatcher abstarctDispatcher,Integer[] floors) {
        for (Integer floor : floors) {
            Floor floor1 = abstarctDispatcher.getFloor(floor);
            press(floor1);
            abstarctDispatcher.changeTargetMax(floor);
            floor1.isOpen = true;
        }
    }
    
    @Override
    public void press(Floor floor) {
        floor.upKey = true;
    }
    
}

下降状态

package cn.xx.evevator;



public class DownStatus extends Status{

    public DownStatus(String name) {
        super(name);
    }
    
    @Override
    void handler(AbstarctDispatcher abstarctDispatcher,Integer[] floors) {
        for (Integer floor : floors) {
            Floor floor1 = abstarctDispatcher.getFloor(floor);
            press(floor1);
            abstarctDispatcher.changeTargetMax(floor);
            floor1.isOpen = true;
        }
    }

    @Override
    public void press(Floor floor) {
        floor.downKey = true;
    }
}

停止状态

package cn.xx.evevator;
public class StopStatus extends Status{
    
    public StopStatus(String name) {
        super(name);
    }
    
    @Override
    void handler(AbstarctDispatcher abstarctDispatcher,Integer[] floors) {
    }

    @Override
    public void press(Floor floor) {
        floor.upKey = false;
        floor.downKey = false;
    }

}

人员类

package cn.xx.evevator;

import org.springframework.util.StringUtils;

public class Person {
    protected final Floor floor;
    protected final AbstarctDispatcher abstarctDispatcher;
    protected final Integer[] expectFloor;
    protected final String name;
    protected final Status status;

    private Person(AbstarctDispatcher abstarctDispatcher, Integer[] expectFloor, String name,Floor floor,Status status) {
        this.abstarctDispatcher = abstarctDispatcher;
        this.expectFloor = expectFloor;
        this.name = name;
        this.floor = floor;
        this.status = status;
        if (abstarctDispatcher.abstractEvevator.targetFloorMax < floor.currentFloor){
            abstarctDispatcher.abstractEvevator.targetFloorMax = floor.currentFloor;
        }
    }


    public void press(Integer[] floor){
        abstarctDispatcher.pressFloor(floor);
    }


    public void elevatorIsHere(int floor){
        System.out.print(floor+"层到了，"+this.name+"请进电梯！期望去：");
        for (int i = 0; i < expectFloor.length; i++) {
            if(i==expectFloor.length-1){
                System.out.println(expectFloor[i]+"层 ");
            }else{
                System.out.print(expectFloor[i]+"层和");
            }
        }
        press(expectFloor);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class Builder{
        private AbstarctDispatcher abstarctDispatcher;
        private Integer[] expectFloor;
        private String name;
        private Floor floor;
        private Status status;

        public Builder(AbstarctDispatcher abstarctDispatcher,Status status){
            this.abstarctDispatcher = abstarctDispatcher;
            this.status = status;
        }

        public Builder expectFloor(Integer[] expectFloor){
            this.expectFloor = expectFloor;
            return this;
        }

        public Builder name(String name){
            if (StringUtils.isEmpty(name)){
                this.name = "";
            }else{
                this.name = name;
            }
            return this;
        }
        public Builder floor(Floor floor){
            this.floor = floor;
            return this;
        }


        public Person build(){
            return new Person(abstarctDispatcher,expectFloor,name,floor,status);
        }

    }

}

状态common

package cn.xx.evevator;

public class StatusCommon {

    public static final UpStatus upstatus = new UpStatus("上升");
    public static final DownStatus downStatus = new DownStatus("下降");
    public static final StopStatus stopStatus = new StopStatus("停止");

}

Context类

public class Context {
    private static final AbstarctDispatcher abstarctDispatcher;
    private static final AbstractEvevator abstractEvevator;
    static {
        abstarctDispatcher = new Dispatcher();
        abstractEvevator = new Evevator(abstarctDispatcher);
        abstarctDispatcher.setAbstractEvevator(abstractEvevator);
    }

    public static AbstarctDispatcher getDispatcher() {
        return abstarctDispatcher;
    }

    public static AbstractEvevator getEvevator() {
        return abstractEvevator;
    }
}

三、测试

public class Test {
    public static void main(String[] args) throws InterruptedException {
        AbstarctDispatcher dispatcher = Context.getDispatcher();
        // 张三在11层按了上行键 进去电梯后按6楼和8楼
        FloorFactory instance = FloorFactory.getInstance();
        Floor floor8 = instance.getFloor(8);
        Floor floor10 = instance.getFloor(10);
        Floor floor3 = instance.getFloor(3);
        new Thread(()->{
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            System.out.println("==============张三在8层按了下行键 进去电梯后按3楼和1楼==============");
            Person person = new Person
                    .Builder(dispatcher,StatusCommon.downStatus)
                    .name("张三")
                    .expectFloor(new Integer[]{3, 2})
                    .floor(floor8)
                    .build();
           floor8.pressFrom(person);
        }).start();

        new Thread(()->{
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("==============李四在10层按了下行键 进去电梯后按5层==============");
            // 李四在8层按了上行键 进去电梯后按10楼和11楼
            Person person1 = new Person
                    .Builder(dispatcher,StatusCommon.downStatus)
                    .name("李四")
                    .expectFloor(new Integer[]{5})
                    .floor(floor10)
                    .build();
            floor10.pressFrom(person1);
        }).start();
        new Thread(()->{
        System.out.println("==============王五在3层按了上行键 进去电梯后按4楼==============");
        // 王五在3层按了上行键 进去电梯后按9楼和11楼
        Person person3 = new Person
                .Builder(dispatcher,StatusCommon.upstatus)
                .name("王五")
                .expectFloor(new Integer[]{11})
                .floor(floor3)
                .build();
        floor3.pressFrom(person3);

    }).start();
    }
}

运行结果：

在这里插入图片描述

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1494817.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

如何选择适合本产线的数据采集平台？

如何选择适合本产线的数据采集平台？

工业数据采集是指从工业现场的传感器、仪器仪表、设备等数据源中采集数据&#xff0c;并将其传输到计算机系统或云端进行处理、分析和存储的过程。数据采集平台可以将生产过程中的各种数据进行分析和处理&#xff0c;从而实现智能化生产&#xff0c;提高生产效率和产品质量。 …
阅读更多...
Jmeter之Ramp-up Period（in seconds）

Jmeter之Ramp-up Period（in seconds）

1、Ramp-up Period概念 &#xff08;in seconds&#xff09;–并发用户启动周期&#xff0c;告知JMeter 要在多长时间内启动全部Vuser用户。 2、为什么需要有“ramp-up period”&#xff0c;立即启动所有的并发用户数不是更好&#xff1f; 对于绝大多数的网址或应用&#xf…
阅读更多...
18.网络游戏逆向分析与漏洞攻防-网络通信数据包分析工具-数据分析工具数据与消息配置的实现

18.网络游戏逆向分析与漏洞攻防-网络通信数据包分析工具-数据分析工具数据与消息配置的实现

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 上一个内容&#xff1a;17.数据分析工具配置功能的实现 码云地址&#xff08;master 分支&#xff09;&#xff1a;https://gitee.com/dye_your_fingers/titan…
阅读更多...
数据库搭建11.2

数据库搭建11.2

数据库之搭建 1、rpm -qa|grep 服务名称 案例&#xff1a;rpm -qa|grep mysql 2、将所有msyql的包删除干净 删除方法&#xff1a; &#xff08;1&#xff09;yum remove mysql * 删除linux中的数据库 &#xff08;2&#xff09;yum erase 包名 &#xff0…
阅读更多...
微前端之什么是微前端

微前端之什么是微前端

什么是微前端 微前端分类 基于路由的微前端&#xff1a;组件化微前端&#xff1a;iframe嵌入式微前端&#xff1a; 优点缺点 动态加载/懒加载微前端&#xff1a;微应用容器化方案&#xff1a; 微前端解决方案 single-spa阿里巴巴 Cloud Alfaiframe 方案Web ComponentsModule Fe…
阅读更多...
蓝桥杯-Set

蓝桥杯-Set

目录 HashSet类常用方法 1 add(Object obj)方法 2 size() 方法 3 remove(Object obj)方法 4 contains()方法 5 clear() 方法 例题实战 set 一个不允许出现重复的元素&#xff0c;并且无序的集合&#xff0c;主要有HashSet实现类。 在判断重复元素的时候&#xff0c;Set集…
阅读更多...
springcloud：3.5测试慢调用熔断降级

springcloud：3.5测试慢调用熔断降级

服务提供者【test-provider8001】 Openfeign远程调用服务提供者搭建 文章地址http://t.csdnimg.cn/06iz8 相关接口 测试远程调用&#xff1a;http://localhost:8001/payment/index 服务消费者【test-consumer-resilience4j8004】 Openfeign远程调用消费者搭建 文章地址http://t…
阅读更多...
java 中 string常用方法及相关的例子

java 中 string常用方法及相关的例子

我将为您详细讲解 Java 中 String 类的常用方法及其相关例子。String 类是 Java 中最常用的类之一&#xff0c;它代表字符串&#xff0c;提供了许多用于操作字符串的方法。 1. 字符串比较 - equals(Object obj): 比较字符串的内容是否相等。 - equalsIgnoreCase(String str): 比…
阅读更多...
【官宣】2024广州国际酒店工程家具及商业空间展览会

【官宣】2024广州国际酒店工程家具及商业空间展览会

2024广州国际酒店工程家具及商业空间展览会 Guangzhou International Hotel Engineering Furniture and commercial space exhibition 2024 时间&#xff1a;2024年12月19-21日 地点&#xff1a;中国进出口商品交易会展馆 承办单位&#xff1a;广州佛兴英耀展览服务有…
阅读更多...
9.12零钱兑换（LC518-M）（开始完全背包，与01背包的不同仅在于遍历顺序）

9.12零钱兑换（LC518-M）（开始完全背包，与01背包的不同仅在于遍历顺序）

算法&#xff1a; 这是一道典型的背包问题&#xff0c;一看到钱币数量不限&#xff0c;就知道这是一个完全背包。 但本题和纯完全背包不一样&#xff0c;纯完全背包是凑成背包最大价值是多少&#xff0c;而本题是要求凑成总金额的物品组合个数&#xff01; 动规五步曲&#…
阅读更多...
[Redis]——数据一致性，先操作数据库，还是先更新缓存？

[Redis]——数据一致性，先操作数据库，还是先更新缓存？

目录 一、操作缓存和数据库时有三个问题需要考虑&#xff1a; 1.删除缓存还是更新缓存&#xff1f; 2.如何保证缓存与数据库的操作同时成功或失效 3.先操作缓存还是先操作数据库&#xff08;多线程并发问题&#xff09; 二、 缓存更新的最佳策略 一、操作缓存和数据库时有…
阅读更多...
网络学习：Vlan间路由

网络学习：Vlan间路由

目录 一、vlan间路由实现的方法 二、精确匹配转发&#xff08;交换机&#xff09;流程 三、最长匹配转发&#xff08;路由器&#xff09; 四、交换机最长匹配转发 五、总结 一、vlan间路由实现的方法 方法1&#xff1a;使用路由器的物理接口 特点&#xff1a;在路由器上…
阅读更多...
LeetCode-第67题-二进制求和

LeetCode-第67题-二进制求和

1.题目描述 给你两个二进制字符串 a 和 b &#xff0c;以二进制字符串的形式返回它们的和。 2.样例描述 3.思路描述 将两个二进制字符串转换成整型&#xff0c;然后相加后的整型转为二进制字符串 4.代码展示 class Solution(object):def addBinary(self, a, b):# 将字符串…
阅读更多...
Linux 之二：CentOS7 的 IP 常用命令和配置及 xshell 基本使用方法

Linux 之二：CentOS7 的 IP 常用命令和配置及 xshell 基本使用方法

1. 进入虚拟机 点击右键---进入终端--输入 ip adrr 或 ifconfig 查看ip地址 下面输入命令 ifconfig&#xff08;注意&#xff1a;不是 ipconfig &#xff09; 或 ip addr 来查看当前系统 IP 查看到IP 后&#xff0c;比如&#xff1a;上面是 192.168.184.137 1.1 IP 常用命令…
阅读更多...
（文末送书）《低代码平台开发实践：基于React》

（文末送书）《低代码平台开发实践：基于React》

最近&#xff0c;我发现了一个超级强大的人工智能学习网站。它以通俗易懂的方式呈现复杂的概念&#xff0c;而且内容风趣幽默。我觉得它对大家可能会有所帮助&#xff0c;所以我在此分享。点击这里跳转到网站。 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&am…
阅读更多...
LeetCode234.回文链表

LeetCode234.回文链表

题目 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true 输入&#xff1a;head [1,2] 输出&#xff1a;false 思…
阅读更多...
mysql 时间精度问题

mysql 时间精度问题

timestamp到2038年&#xff0c;还有14年时间&#xff0c;一个系统如果能活到那一刻也是相当不错了。 这里先看一下个datetime的问题,下面的插入数据的时间戳是2024-03-06 21:20:50.839 INSERT INTO psi_io_balance ( id, as_id, bill_date, order_id, busi_type, direction, c…
阅读更多...
5. gin集成Gorm

5. gin集成Gorm

文章目录 一&#xff1a;连接DB二&#xff1a;增删改查三&#xff1a;使用PostMan测试 代码地址&#xff1a;https://gitee.com/lymgoforIT/golang-trick/tree/master/24-gin-learning 本节主要介绍如何使用gin集成gorm&#xff0c;并完成用户的创建、修改、删除、查询等功能 …
阅读更多...
使用Http请求下载文件带来的问题

使用Http请求下载文件带来的问题

java.io.IOException: Broken pipe 当使用http请求的方式将文件作为响应内容给浏览器&#xff0c;这个时候如果浏览器未开启自动下载(浏览器可能会终止这个tcp连接)&#xff0c;文件不会下载成功&#xff0c;但是这个时候请求已经到达服务器&#xff0c;如果这个时候&#xff0…
阅读更多...
《Vite 报错》ReferenceError: module is not defined in ES module scope

《Vite 报错》ReferenceError: module is not defined in ES module scope

ReferenceError: module is not defined in ES module scope 解决方案 postcss.config.js 要改为 postcss.config.cjs&#xff0c;也就是 .cjs 后缀。 原因解析 下图提示&#xff0c;packages.json 中的属性 type 设置为 module。所有 *.js 文件现在都被解释为 ESM&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023