Java基础视频教程-银行业务调度系统

银行业务调度系统，相比上一个的交通灯管理系统，感觉复杂了许多，也许是只看了一遍的原因。

自己凭着印象和加上自己的层次理解做完的。花了不少时间。

这次的题目主要涉及的知识点有：线程池，集合，类的抽象与继承，枚举等

题目需求如下：

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

思路：
根据老师的讲解和结合自己的理解，画了实现的关系图

如图，主要分为三大快，取号机的类，用于存放客户数据的List集合类和服务窗口类

1，有一个集合类，用于存放不同客户类型的数据，对外提供添加和删除数据方法
2，取号机的类，主要功能：产生不同类型客户并将其添加到对应的集合中
因为有三种类型客户，所以使用了三个线程以固定时间频率产生不同类型客户
3，最后是窗口类，因为有三种不同窗口，普通，快速，VIP。而快速、VIP也需要能处理
普通类型客户，于是就将窗口叫号与服务功能抽离出来，封装成一个抽象类，
由普通，快速，VIP三个子类来完成具体操作

首先实现集合类，如下：

package com.itheima.bank;  
  
import java.util.ArrayList;  
import java.util.List;  
/*号码管理器，模式是生产和消费类，所以使用同步锁*/  
public class NumberManager {  
    /*定义号码集合*/  
    private List<Integer> queueNumber = new ArrayList<Integer>();  
    private int number = 0;  
      
    /*添加号码，模拟用户的增加*/  
    public synchronized Integer generateNewManager(){  
        queueNumber.add(++number);  
        return number;  
    }  
      
    /*取出号码，模拟窗口为队列前端用户服务*/  
    public synchronized Integer fetchServiceNumber(){  
        if(queueNumber.size() > 0 ){  
            return queueNumber.remove(0);  
        }else{  
            return null;  
        }  
    }  
}  

然后实现取号功能的类：
类中有三个线程以产生不同类型客户，如下：

package com.itheima.bank;  
  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
public class NumberMachine {  
    /*创建三个号码集合管理对象，分别对应三种不同用户类型*/  
    private static NumberManager commonManager = new NumberManager();  
    private static NumberManager expressManager = new NumberManager();  
    private static NumberManager vipManager = new NumberManager();  
      
    /*获取用户类型*/  
    public static NumberManager getCommonManager() {  
        return commonManager;  
    }  
    public static NumberManager getExpressManager() {  
        return expressManager;  
    }  
    public static NumberManager getVipManager() {  
        return vipManager;  
    }  
  
    /*因为号码管理器只有一个，所以设计成单例模式*/  
    private static NumberMachine instance = new NumberMachine();  
    private NumberMachine(){}  
    public static NumberMachine getInstance(){  
        return instance;  
    }  
      
    /*定义三个线程，分别模拟三种不同类型用户出来*/  
    public void start(){  
        /*每隔1秒出现一名普通用户*/  
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
                    public void run() {  
                        Integer number = commonManager.generateNewManager();  
                        System.out.println("第"+number+"名普通客户正在等待服务!");  
                    }  
                },  
                1,  
                1,  
                TimeUnit.SECONDS  
                );  
          
        /*每隔3秒出现一名快速用户*/  
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
                    public void run() {  
                        Integer number = expressManager.generateNewManager();  
                        System.out.println("第"+number+"名快速客户正在等待服务!");  
                    }  
                },  
                1,  
                3,  
                TimeUnit.SECONDS  
                );  
          
        /*每隔6秒出现一名VIP用户*/  
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
                    public void run() {  
                        Integer number = vipManager.generateNewManager();  
                        System.out.println("第"+number+"名VIP客户正在等待服务!");  
                    }  
                },  
                1,  
                6,  
                TimeUnit.SECONDS  
                );  
    }     
}  

因为只需要一个控制器，所以设计成单例模式

为了更好地区分不同类型客户，声明一个枚举类，表示不同的客户
客户枚举类：

package com.itheima.bank;  
/*客户类型*/  
public enum CustomerType {  
    COMMON,EXPRESS,VIP;  
      
    /*覆写toString方法*/  
    public String toString(){  
        switch(this){  
            case COMMON:  
                return "普通";  
            case EXPRESS:  
                return "快速";  
            case VIP:  
                return "VIP";  
        }  
        return null;  
    }  
}  

在实现主要功能之前，再定义一个时间类，提供静态属性和修改服务时间静态方法，
时间类：

package com.itheima.bank;  
/*时间类，用于设置服务时间*/  
public class Constants {  
  
    public static int MAX_SERVICE_TIME = 10000;  
    public static int MIN_SERVICE_TIME = 1000;  
      
    private Constants(){}  
      
    public static synchronized void setMAX_SERVICE_TIME(int mAX_SERVICE_TIME) {  
        MAX_SERVICE_TIME = mAX_SERVICE_TIME;  
    }  
      
    public static synchronized void setMIN_SERVICE_TIME(int mIN_SERVICE_TIME) {  
        MIN_SERVICE_TIME = mIN_SERVICE_TIME;  
    }  
}  

有了以上的准备，就开始着手服务窗口的实现了。

package com.itheima.bank;  
  
import java.util.Random;  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
/*抽象父类---服务窗口*/  
public abstract class ServiceWindow {  
    private int windowID;  
    private CustomerType type;  
    private NumberManager numberManager;  
      
    /*由子类传递窗口ID、服务客户类型和对应的号码容器*/  
    public ServiceWindow(int windowID,CustomerType type,NumberManager numberManager){  
        this.windowID = windowID;  
        this.type = type;  
        this.numberManager = numberManager;  
    }  
      
    /*抽象父类内部方法，由子类传递参数来实现功能,windowType表示当前服务的窗口类型 
      customerType为当前的客户类型，numberManager对应客户类型的集合数据 */  
    private boolean serve(CustomerType windowType,  
                            CustomerType customerType,  
                            NumberManager numberManager) {  
        String WindowName = windowID+"号"+windowType+"窗口";  
        Integer currentNumber = numberManager.fetchServiceNumber();  
        System.out.println(WindowName+"正在获取"+customerType+"任务");  
        if(currentNumber != null){  
            System.out.println(WindowName+"正在为第"  
                    +currentNumber+"号"+customerType+"客户服务");  
  
            /*服务时间设定*/  
            long beginTime = System.currentTimeMillis();  
            int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;  
            long serveTime = new Random().nextInt(maxRand) + 1 + Constants.MIN_SERVICE_TIME;  
            try {  
                  
                /*设定快速服务时间*/  
                if(windowType.toString().equals("快速")){  
                    Thread.sleep(Constants.MIN_SERVICE_TIME);  
                }else{  
                      
                    /*模拟服务所用时间*/  
                    Thread.sleep(serveTime);  
                }  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            long costTime = System.currentTimeMillis() - beginTime;  
            System.out.println(WindowName+"完成为"  
                    +currentNumber+"号"+customerType+"客户服务，耗时"+(costTime/1000)+"秒");  
            return false;  
        }  
        else{  
            System.out.println(windowID+"号"  
                    +windowType+"窗口没有获取到"+customerType+"任务，正在空闲一秒");  
            return true;  
        }  
    }  
  
    /*外部方法，但核心功能由私有成员serve方法实现*/  
    public void start(){  
        /*定义一个线程 周期性的循环执行叫号，周期为1秒*/  
        Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(  
                new Runnable(){  
                    public void run(){  
                        /*serve() 返回值为boolean型，true代表没有叫到号*/  
                        if(serve(type,type,numberManager)){  
                            switch(type){  
                            case EXPRESS:  
                                /*此处实现 快速窗口为普通用户服务*/  
                                serve(CustomerType.EXPRESS,  
                                        CustomerType.COMMON,  
                                        NumberMachine.getCommonManager());  
                                break;                                
                            case VIP:  
                                /*此处实现 VIP窗口为普通用户服务*/  
                                serve(CustomerType.VIP,  
                                        CustomerType.COMMON,  
                                        NumberMachine.getCommonManager());  
                                break;  
                            }  
                        }  
                    }  
                },  
                1,  
                1,  
                TimeUnit.SECONDS  
                );  
    }  
      
}  

主体功能实现后，接下来只要创建窗口的三个子类：
普通窗口：

package com.itheima.bank; 
/*普通窗口*/ 
public class CommonServiceWindow extends ServiceWindow { 

public CommonServiceWindow(int ID){ 
super(ID,CustomerType.COMMON,NumberMachine.getCommonManager()); 
} 
} 

快速窗口：

package com.itheima.bank; 
/*快速窗口*/ 
public class ExpressServiceWindow extends ServiceWindow { 

public ExpressServiceWindow(int ID){ 
super(ID,CustomerType.EXPRESS,NumberMachine.getExpressManager()); 
} 
} 

VIP窗口：

package com.itheima.bank; 

/*VIP窗口*/ 
public class VipServiceWindow extends ServiceWindow { 

public VipServiceWindow(int ID){ 
super(ID,CustomerType.VIP,NumberMachine.getVipManager()); 
} 
}

 
至此，功能大致完成，
现在创建一个测试Main类：

package com.itheima.bank; 

public class MainTest { 
public static void main(String[] args){ 
/*开启四个普通窗口，并制定ID号*/ 
new CommonServiceWindow(1).start(); 
new CommonServiceWindow(2).start(); 
new CommonServiceWindow(3).start(); 
new CommonServiceWindow(4).start(); 

/*开启一个快速窗口*/ 
new ExpressServiceWindow(1).start(); 

/*开启一个VIP窗口*/ 
new VipServiceWindow(1).start(); 

/**/ 
NumberMachine.getInstance().start(); 
} 
} 

创建了4个普通窗口类的子类对象，快速和VIP窗口类对象各1个
最后启动取号功能。

总结：做完两个7K面试题后，对面向对象设计有了一个初步的认识，其中最重要的是
上层设计要合理，下层的技术层面和代码就不会乱，也不会有东拼西凑的感觉，而这
两个系统里多线程技术是实现功能的重点。但使用的时候还是需要多查阅资料，可见
要学好Java还任重道远。