客户、窗口-银行业务面试题，java代码。 -by小雨

最新推荐文章于 2022-05-11 20:51:42 发布

dyl_love98

最新推荐文章于 2022-05-11 20:51:42 发布

阅读量323

点赞数

文章标签：客户窗口-

PS:今天上午，非常郁闷，有很多简单基础的问题搞得我有些迷茫，哎，码代几天不写就忘。目前又不当COO，还是得用心记码代哦！

------- android培训、java培训、待期与您交流！ ----------

银行业务调度统系

拟模现实银行业务调度统系逻辑，体具求需如下：

银行内有6个业务窗口，1 - 4号窗口为一般窗口，5号窗口为倏地窗口，6号窗口为VIP窗口。
有三种对应型类的客户：VIP客户，一般客户，倏地客户（理办如交水电费、电话费之类业务的客户）。
异步随机成生各种型类的客户，成生各型类用户的率概比例为： VIP客户：一般客户：倏地客户 = 1 ：6 ：3。
客户理办业务所需间时有最大值和最小值，在该范围内随机设定个每VIP客户以及一般客户理办业务所需的间时，倏地客户理办业务所需间时为最小值（提示：理办业务的程过可通过线程Sleep的方法拟模）。
各型类客户在其对应窗口按次序顺次理办业务。
当VIP（6号）窗口和倏地业务（5号）窗口没有客户等待理办业务的时候，这两个窗口可以处置一般客户的业务，而一旦有对应的客户等待理办业务的时候，则优先处置对应客户的业务。
随机成生客户间时间隔以及业务理办间时最大值和最小值自定，可以设置。
不要求现实GUI，只斟酌统系逻辑现实，可通过Log方法展示序程行运结果。

码代及注释：

import java.util.*;

public class Bank {
    //定义服务间时常量，前面要用。
    public static final long SHORTEST_SEVICE_TIME = 1000;
    public static final long LONGEST_SEVICE_TIME = 10000;
    public static final long BETWEEN_SEVICE_TIME = LONGEST_SEVICE_TIME - SHORTEST_SEVICE_TIME;

    public static void main (String[] args){
        //定义3个列队。因为是先进先出，所以用到LinkedList效率会比较好，用Collections.synchronizedList让线程安全。
        List<Integer> comm = Collections.synchronizedList (new LinkedList<Integer>());
        List<Integer> exp = Collections.synchronizedList (new LinkedList<Integer>());
        List<Integer> vip = Collections.synchronizedList (new LinkedList<Integer>());
        //立建银行窗口
        BankWindow comm1 = new BankWindow(1,WindowType.COMM);
        BankWindow comm2 = new BankWindow(2,WindowType.COMM);
        BankWindow comm3 = new BankWindow(3,WindowType.COMM);
        BankWindow comm4 = new BankWindow(4,WindowType.COMM);
        BankWindow exp5  = new BankWindow(5,WindowType.EXP);
        BankWindow vip6  = new BankWindow(6,WindowType.VIP);
        //银行窗口多线程开启
        FuWuGuKe f1 = new FuWuGuKe(comm1,comm, exp, vip);
        FuWuGuKe f2 = new FuWuGuKe(comm2,comm, exp, vip);
        FuWuGuKe f3 = new FuWuGuKe(comm3,comm, exp, vip);
        FuWuGuKe f4 = new FuWuGuKe(comm4,comm, exp, vip);
        FuWuGuKe f5 = new FuWuGuKe(exp5,comm, exp, vip);
        FuWuGuKe f6 = new FuWuGuKe(vip6,comm, exp, vip);
        Thread t1 = new Thread(f1);
        Thread t2 = new Thread(f2);
        Thread t3 = new Thread(f3);
        Thread t4 = new Thread(f4);
        Thread t5 = new Thread(f5);
        Thread t6 = new Thread(f6);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        //列队就不必额定的线程了，直接放在主线程里。
        while (true){
            DuiLie.shengChengDuiLie(comm, exp, vip);
            mySleep((long)(Math.random()*900) + 200);
        }
    }
    //定义了一个线程休眠的方法，不然要try catch好多遍。
    public static void mySleep(long haomiao){
        try{
            Thread.sleep(haomiao);
        }
        catch(Exception e){
        }
    }            
}
//服务客顾这个类准备用多线程
class FuWuGuKe implements Runnable{
    private BankWindow bw;
    private List<Integer> comm;
    private List<Integer> exp;
    private List<Integer> vip;
    
    
    //创建对象的时候把bankwindow传进来，在run里用使对应对象的方法。
    public FuWuGuKe(BankWindow bw, List<Integer> comm, List<Integer> exp, List<Integer> vip){
        this.bw = bw;
        this.comm = comm;
        this.exp = exp;
        this.vip = vip;
    }
    public void run(){
        while(true){
            //对象（bankwindow）先服务自己型类 的客顾
            bw.service(bw.getType(), comm, exp, vip);
        }
    }
}
class BankWindow{
    //定义窗口的id和型类，以及名字
    private int id;
    private WindowType type;
    private String windowName;
    //构造函数，设置窗口id和型类。
    BankWindow(int id, WindowType type){
        this.id = id;
        this.type = type;
        windowName = "第"+id+"号"+type +"窗口";
    }
    //返回对象的窗口型类的方法
    public WindowType getType(){
        return this.type;
    }
    //服务客顾的方法。因为：要处置对应型类的客顾，还有可能用使到3个型类的列队，所以部全当参数传入
    public void service (WindowType type, List comm, List exp, List vip){
        int customID;
        long serviceTime;
        System.out.println(windowName+"正在取获" + type + "客户");
        if (type == WindowType.COMM){
            if (comm.size() != 0){//一般型类的列队如果不为空，则处置一般客顾
                //处置列队中的第一个客户，把客户的ID给customID，在打印语句中用使，下同。
                customID = (int)comm.remove(0);
                System.out.println(windowName+"取获到客户："+customID+"一般客户");
                //盘算服务间时（位单毫秒），赋值给serviceTime，在打印语句中用使，下同。
                serviceTime = Bank.SHORTEST_SEVICE_TIME + (long)(Math.random() * Bank.BETWEEN_SEVICE_TIME) ;
                //用调Bank类中的mySleep方法，防止多次写try catch下同。
                Bank.mySleep(serviceTime);
                System.out.println(windowName+":"+customID+"一般客户服务毕完,服务间时："+ serviceTime +"毫秒");
            }
            else{//没有一般客顾则苏息
                System.out.println(windowName+":没有待服务的一般客户，苏息。");
                Bank.mySleep(1000);
            }
        }
        else if (type == WindowType.EXP){//倏地型类的列队如果不为空，则处置倏地客顾
            if (exp.size() != 0){
                customID = (int)exp.remove(0);
                System.out.println(windowName+"取获到客户："+customID+"倏地客户");
                serviceTime = Bank.SHORTEST_SEVICE_TIME;
                //倏地客顾服务间时为最短服务间时。
                Bank.mySleep(serviceTime);
                System.out.println(windowName+":"+customID+"倏地客户服务毕完,服务间时："+ serviceTime +"毫秒");
            }
            else {//没有倏地型类的客顾，则处置一般客顾。有点递归的道味，不过由于处置一般客顾的方法会苏息并结束，所以不是递归。下同
                System.out.println(windowName+"没有取获到倏地客户；试尝取获一般客户");
                service(WindowType.COMM, comm,  exp, vip);
            }
        }
        else if (type == WindowType.VIP){//高朋型类的列队如果不为空，则处置高朋客顾
            if (vip.size() != 0){
                customID = (int)vip.remove(0);
                System.out.println(windowName+"取获到客户："+customID+"高朋客户");
                serviceTime = Bank.SHORTEST_SEVICE_TIME + (long)(Math.random() * Bank.BETWEEN_SEVICE_TIME) ;
                Bank.mySleep(serviceTime);
                System.out.println(windowName+":"+customID+"高朋客户服务毕完,服务间时："+ serviceTime +"毫秒");
            }
            else{//没有型类型类的客顾，则处置一般客顾。
                System.out.println(windowName+"没有取获到高朋客户；试尝取获一般客户");
                service(WindowType.COMM, comm,  exp, vip);
            }
        }        
    }
}
//成生列队的类
class DuiLie{
    //定义了静态列队编号，随着类的载加而载加，
    private static Integer commCust=0;
    private static  Integer expCust=0;
    private static  Integer vipCust=0;
    //法无new对象，没有意义。
    private DuiLie(){};
    //每次发生一个随机数，根据随机数的小大，往对应的列队里参加对应编号的成员。
    public static void shengChengDuiLie(List comm, List exp, List vip){
        double randNum = Math.random();
        //三种客顾的比例为6：3：1，所以分为用0.6和0.9把随机数分为3种型类。
        if (randNum < 0.6){
            commCust++;
            comm.add(commCust);
            System.out.println(commCust+"号一般用户到达银行");
        }
        else if(randNum < 0.9){
            expCust++;
            exp.add(expCust);
            System.out.println(expCust+"号倏地用户到达银行");
        }
        else{
            vipCust++;
            vip.add(vipCust);
            System.out.println(vipCust+"号高朋用户到达银行");
        }
    }
}
//定义一个枚举，我也不是很懂。
enum WindowType{
    COMM, EXP, VIP;
    public String toString(){
        switch (this){
        case COMM:
            return "一般";
        case EXP:
            return "倏地";
        case VIP:
            return "高朋";
        }
        return "";
    }
}

有一个问题：在创建对象和线程的时候，码代量大重复，如何增加码代量？

Thread t1 = new Thread(new FuWuGuKe(new BankWindow(1,WindowType.COMM)));
Thread t2 = new Thread(new FuWuGuKe(new BankWindow(2,WindowType.COMM)));
Thread t3 = new Thread(new FuWuGuKe(new BankWindow(3,WindowType.COMM)));
Thread t4 = new Thread(new FuWuGuKe(new BankWindow(4,WindowType.COMM)));
Thread t5 = new Thread(new FuWuGuKe(new BankWindow(5,WindowType.EXP)));
Thread t6 = new Thread(new FuWuGuKe(new BankWindow(6,WindowType.VIP)));
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
种这3句变一句的该应不算。

文章结束给大家分享下程序员的一些笑话语录：大家喝的是啤酒，这时你入座了。
你给自己倒了杯可乐，这叫低配置。
你给自已倒了杯啤酒，这叫标准配置。
你给自己倒了杯茶水，这茶的颜色还跟啤酒一样，这叫木马。
你给自己倒了杯可乐，还滴了几滴醋，不仅颜色跟啤酒一样，而且不冒热气还有泡泡，这叫超级木马。
你的同事给你倒了杯白酒，这叫推荐配置。
菜过三巡，你就不跟他们客气了。
你向对面的人敬酒，这叫p2p。
你向对面的人敬酒，他回敬你，你又再敬他……，这叫tcp。
你向一桌人挨个敬酒，这叫令牌环。
你说只要是兄弟就干了这杯，这叫广播。
有一个人过来向这桌敬酒，你说不行你先过了我这关，这叫防火墙。
你的小弟们过来敬你酒，这叫一对多。
你是boss，所有人过来敬你酒，这叫服务器。
酒是一样的，可是喝酒的人是不同的。
你越喝脸越红，这叫频繁分配释放资源。
你越喝脸越白，这叫资源不释放。
你已经醉了，却说我还能喝，叫做资源额度不足。
你明明能喝，却说我已经醉了，叫做资源保留。
喝酒喝到最后的结果都一样
你突然跑向厕所，这叫捕获异常。
你在厕所吐了，反而觉得状态不错，这叫清空内存。
你在台面上吐了，觉得很惭愧，这叫程序异常。
你在boss面前吐了，觉得很害怕，这叫系统崩溃。
你吐到了boss身上，只能索性晕倒了，这叫硬件休克。