------- android培训、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面试题,对我理解面向对象编程有很大的帮助,尤其深深的体会到上层系统的分析,对下层代码的书写起到了及其重要的帮助。同时,加强了对于多线程的使用的理解,受益匪浅。这两道题要之后也要好好的进行反复分析研究,对自己会有更多的提升。