这篇文章会学到的相关新知识点
Executors(遗嘱执行人,executor:执行者)、Runnable（可运行）、if语句和switch的区别？、switch的数据类型只能是哪些？、面向对象设计的一个重要原则
Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(command,initialDelay,delay,unit);
跟着大牛视频写出来的
模拟实现银行业务调度系统
具体需求如下
1、银行内有6个业务窗口，1-4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为vip窗口。
2、有三种对应类型的客户，普通客户，快速客户，VIP客户。
3、异步随机生成各种类型的客户，生成各种类型用户的概率比例为：普通客户:快速客户:VIP客户=3:6:1
4、客户办理业务所需的时间有最大值和最小值，在该范围内随机设定每个客户办理业务所需的时间，而快速用户所需的时间设为最小值。（提示：办理业务的过程可以通过线程Sleep的方式模拟）。
5、各类型客户在其对的应窗口按顺序依次办理业务。
6、当VIP客户和快速业务窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
7、不用实现GUI界面。
面向对象的分析与设计
有三种对应类型的客户：VIP客户,普通客户,快速客户,异步随机生成各种类型的客户，各类型的客户在其对应窗口按顺序依次办理业务。
各类型客户在其对应窗口按顺序依次办理业务，准确的说，应该是窗口依次叫好。
一个客户从进入银行到离开银行，在这系统中做了些什么事
程序的类图
图中◇——代表聚合关系，——代表关联关系。getInstance()是静态方法。因为系统中只有一个取号机，所以这里用单例设计模式。
参看百度百科的解释http://baike.baidu.com/view/977673.htm?fr=aladdin
代码实现
ServiceWindow类的实现
package com.itcast.bank;
import java.util.Random;
import java.util.concurrent.Executors;
import constants.Constant;
import enums.CustomerType;
/**
* 服务窗口
*
* @author Terry
* @date 2014-6-2
*
*/
public class ServiceWindow {
public ServiceWindow(){}//无参构造
//有参构造
public ServiceWindow(CustomerType windowType,int windowId){
this.windowType = windowType;
this.windowId = windowId;
}
//private int windowType;//一般的写法，但这里只有三种类型，普通，特快，VIP，这里用枚举比较好
//这两个方法也可以做为构造方法传入，但是不那么做，如果弄成构造函数传值的话，在new一个此对象的时候就
//确定了它的类型和编号，不便于更改。
private CustomerType windowType = CustomerType.COMMON;//默认类型COMMON
private int windowId = 1;
public void setWindowType(CustomerType windowType) {
this.windowType = windowType;
}
public void setWindowId(int windowId) {
this.windowId = windowId;
}
public void start(){
//Executors（执行者）线程池
Executors.newSingleThreadExecutor().execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
// 问题：if语句和swicth语句的区别？
// if (windowType == CustomerType.COMMON) {
//
// }else if(){
//
// }else if(){
//
// }
switch (windowType) {
case COMMON:
commonService();
break;
case EXPRESS:
NumberMachine.getInstance().getExpressManager();
expressService();
break;
case VIP:
NumberMachine.getInstance().getVIPManager();
VIPService();
break;
default:
break;
}
}
}
});
}
/**
* 普通服务
*/
private void commonService(){
String windowName = "第"+windowId+"号"+windowType+"窗口";
//System.out.println(windowName + "正在获取普通服务任务！");//这代码不应该写在这里，应该写在下面一行代码的后面，这样结果更直观
Integer number = NumberMachine.getInstance().getCommomManager().fetchServiceNumber();
System.out.println(windowName + "正在获取普通服务任务！");
if(number != null){
long beginTime = System.currentTimeMillis();
int maxServiceTime =Constant.MAX_SERVICE_TIME - Constant.MIN_SERVECE_TIME;
//获取1000-10000的随机数
long serviceTime = new Random().nextInt(maxServiceTime) + 1 + Constant.MIN_SERVECE_TIME;
try {
Thread.sleep(serviceTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = System.currentTimeMillis()-beginTime;
System.out.println(windowName + "为第"+number+"个"+"普通"+"客户完成服务,耗时" + costTime/1000+"秒");
}else{
System.out.println(windowName + "没有取到服务任务！先休息1秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 快速服务
*/
private void expressService(){
String windowName = "第"+windowId+"号"+windowType+"窗口";
//System.out.println(windowName + "正在获取快速服务任务！");
Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
System.out.println(windowName + "正在获取快速服务任务！");
if(number != null){
long beginTime = System.currentTimeMillis();
//int maxServiceTime =Constant.MAX_SERVICE_TIME - Constant.MIN_SERVECE_TIME;
//long serviceTime = new Random().nextInt(maxServiceTime) + 1 + Constant.MIN_SERVECE_TIME;
try {
Thread.sleep(Constant.MIN_SERVECE_TIME);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = System.currentTimeMillis()-beginTime;
System.out.println(windowName + "为第"+number+"个"+"快速"+"客户完成服务,耗时" + costTime/1000+"秒");
}else{
System.out.println("没有取到快速服务！那我就取普通业务服务！");
commonService();
}
}
private void VIPService(){
String windowName = "第"+windowId+"号"+windowType+"窗口";
Integer number = NumberMachine.getInstance().getVIPManager().fetchServiceNumber();
System.out.println(windowName + "正在获取VIP服务任务！");
if(number != null){
long beginTime = System.currentTimeMillis();
int maxServiceTime =Constant.MAX_SERVICE_TIME - Constant.MIN_SERVECE_TIME;
long serviceTime = new Random().nextInt(maxServiceTime) + 1 + Constant.MIN_SERVECE_TIME;
try {
Thread.sleep(serviceTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = System.currentTimeMillis()-beginTime;
System.out.println(windowName + "为第"+number+"个"+"VIP"+"客户完成服务,耗时" + costTime/1000+"秒");
}else{
System.out.println("没有取到VIP服务任务，接着取普通任务！");
commonService();
}
}
}
NumberManager类的实现
package com.itcast.bank;
import java.util.ArrayList;
import java.util.List;
/**
* 生产号码的机器
*
* @author Terry
* @date 2014-6-1
*
*/
public class NumberManager {
//上一个号码
private int lastNumber = 1;
//这里用List，是面向接口编程，可以使程序有更好的延展性
private List<Integer> queueNumber = new ArrayList<Integer>();
/**
* 取号的方法，客户来了就调用这方法
* @return
*/
public synchronized Integer generateNewManager(){
queueNumber.add(lastNumber);
return lastNumber++;
}
/**
* 获取号码的方法，窗口没业务办理时，要领任务时，调用这个方法
* 原来的想法是返回 int 基本类型的但是有问题，详细了解的时候就进方法看.
* @return
*/
public synchronized Integer fetchServiceNumber(){
if(queueNumber.size() > 0){
//如果下面的queueNumber当中没有元素，那它的remove方法返回的值是null,而要让null
//强转成int是不行的,所以上面方法的返回值改为了integer
return queueNumber.remove(0);//这里是返回移除的对象，现在返回的是Integer因为List<Integer> queueNumber = new Array
//List<Integer>();如果将Integer改成Object那前面返回的就是Object
}
return null;
}
}
NumberMachine类的实现
package com.itcast.bank;
/**
* 管理号码的机器
*
* @author Terry
* @date 2014-6-1
*
*/
public class NumberMachine {
//普通号码生产机
private NumberManager commomManager = new NumberManager();
//特快号码生产机
private NumberManager expressManager = new NumberManager();
//VIP客户号码生产机
private NumberManager VIPManager = new NumberManager();
/**
* 获得普通号码生产机
* @return
*/
public NumberManager getCommomManager() {
return commomManager;
}
/**
* 获得快速号码生产机
* @return
*/
public NumberManager getExpressManager() {
return expressManager;
}
/**
* 获得VIP号码生产机
* @return
*/
public NumberManager getVIPManager() {
return VIPManager;
}
private NumberMachine(){}
/**
* 得到单例
* @return
*/
public static NumberMachine getInstance(){
//return new NumberMachine();这种写法应该不是单列设计模式，感觉这样写每次返回的都是新的一个对象
return instance;
}
private static NumberMachine instance = new NumberMachine();
}
顾客类型的枚举类CustomerType实现
package enums;
/**
* 顾客类型
* customer：顾客
* @author Terry
* @date 2014-6-2
*
*/
public enum CustomerType {
COMMON,EXPRESS,VIP;
@Override
public String toString(){
switch (this) {
case COMMON:
return "普通";
case EXPRESS:
return "快速";
case VIP:
return name();
}
return null;
}
}
窗口类型的枚举类WindowType实现
package enums;
/**
* 窗口类型
*
* @author Terry
* @date 2014-6-2
*
*/
public enum WindowType {
/**
* 普通窗口
*/
ORDINARYWINDOW,FASTWINDOW,VIDWINDOW
}
Constant类实现Constant：常量
package constants;
public class Constant {
public final static int MAX_SERVICE_TIME = 10000;
public final static int MIN_SERVECE_TIME = 1000;
public final static int COMMON_CUSTOMER_INTERVAL_TIME = 1;
}
程序入口Main类的实现
package main;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.itcast.bank.NumberMachine;
import com.itcast.bank.ServiceWindow;
import constants.Constant;
import enums.CustomerType;
/**
* 程序的入口类
*
* @author Terry
* @date 2014-6-2
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 创建4个普通类型的窗口
*/
for (int i = 1; i < 5; i++) {
ServiceWindow commonWindow = new ServiceWindow();
commonWindow.setWindowId(i);
commonWindow.start();
}
/**
* 创建快速服务类型的窗口
*/
ServiceWindow expressWindow = new ServiceWindow();
expressWindow.setWindowType(CustomerType.EXPRESS);
expressWindow.start();
/**
* 创建VIP类型的窗口
*/
ServiceWindow vipWindow = new ServiceWindow();
vipWindow.setWindowType(CustomerType.VIP);
vipWindow.start();
//调度线程池（Scheduled：调度，Pool：池子）
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Integer number = NumberMachine.getInstance().getCommomManager().generateNewManager();
System.out.println(number + "号普通客户等待服务！");
}
},
0,
Constant.COMMON_CUSTOMER_INTERVAL_TIME,
TimeUnit.SECONDS
);
//调度线程池（Scheduled：调度，Pool：池子）
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();
System.out.println(number + "号快速客户等待服务！");
}
},
0,
Constant.COMMON_CUSTOMER_INTERVAL_TIME * 2,
TimeUnit.SECONDS
);
//调度线程池（Scheduled：调度，Pool：池子）
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Integer number = NumberMachine.getInstance().getVIPManager().generateNewManager();
System.out.println(number + "号VIP客户等待服务！");
}
},
0,
Constant.COMMON_CUSTOMER_INTERVAL_TIME * 6,
TimeUnit.SECONDS
);
}
}
到这里程序就全部写完了
看了张孝祥老师的视频后自己思考写出来的
(下面之所以重复是为了看的时候方便点，免得看的时候一会上，一会下的麻烦)
模拟实现银行业务调度系统
具体需求如下
1、银行内有6个业务窗口，1-4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为vip窗口。
2、有三种对应类型的客户，普通客户，快速客户，VIP客户。
3、异步随机生成各种类型的客户，生成各种类型用户的概率比例为：普通客户:快速客户:VIP客户=3:6:1
4、客户办理业务所需的时间有最大值和最小值，在该范围内随机设定每个客户办理业务所需的时间，而快速用户所需的时间设为最小值。（提示：办理业务的过程可以通过线程Sleep的方式模拟）。
5、各类型客户在其对的应窗口按顺序依次办理业务。
6、当VIP客户和快速业务窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
7、不用实现GUI界面。
一个客户从进入银行到离开银行，在这系统中做了些什么事(这里应该使用用例图吧)
这里可以用模板方法设计模式（行为型的设计模式）。客户的行为大致上是一致的就是：到银行------->去取号------>等待区等待------>办理业务------>离开银行，只是办理的业务不同而已。
面向对象的分析与设计
步骤一：找系统中用到的类和方法
找主要名词：
业务窗口：普通业务窗口、快速业务（Business）窗口、vip业务窗口
客 户：普通类型客户、快速类型客户、vip类型客户
办理业务的时间、
（附加的隐含名词：取号机、小票、等待区）
找主要动词
取号机生成小票、窗口办理业务、随机设定办理业务的时间
（附加的隐含动词：取号、窗口叫号）
上面的名词动词找完了，一般我们经常去银行处理业务吧，到银行后都是先去找取号机去取号，然后得到小票，去等待区等待窗口叫号，最后去办理业务。由于取票机是不会产生下票的，只是在他的内部有产生小票的机器，所以还有个对象下票制作机。所以这时候就会多了一些隐含名词和动词
步骤二：根据上面找到的类和方法，画类图
TakeANumberMachine取票机的类，本打算偷懒把创建三种票的方法，设计给取票机的，但是到后面出了问题，就是不好给票计数，vip票有vip票的计数器，普通票有普通票的计数器，快速票有快速票的计数器都交给取票机的话会混乱，也违背了面向对象的5条基本设计原则之单一职责原则。
单一职责原则：阐述的类容是：一个类，应该只有一个引起它变化的原因。即一个类中应该只有一种职责，如果一个类有一个以上的职责，那么这些职责就会耦合在一起。当一个职责发生变化时，可能会影响其他的职责。另外，多个职责偶合在一起，会影响复用性。
在单一职责中，将职责定义为“变化的原因”，也就是说一个类应该具有一个引起它改变的原因，不能存在多个变化原因。这个定义很简单，也很容易理解，但是在实际的应用上却是比较难以掌控的。因为，"变化的原因"很难界定，而且有一些“变化”可能还是个未知数不能确定，各种实际情况都会存在。我们在做具体项目的时候，需要仔细分析类中的功能职责，通常意味着单一的功能，因此不要让类实现过多的功能点，以保证一个实体类只有一个引起它变化的原因。
如何实现单一职责原则：一句话，尽可能地让一个类实现单一的功能点。
上面大量用到抽象类，下次试试用接口
代码实现：
工程目录结构图、
各类的实现：
BusinessTimer类
package com.itcast;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : BusinessTimer.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 业务时间类，保持与时间相关的常量，后面好像没用到
*
* @author Terry
* @date 2014-6-3
*
*/
public class BusinessTimer {
private final int MINTIME = 1000;
private final int MAXTIME = 10000;
public int getMINTIME() {
return MINTIME;
}
public int getMAXTIME() {
return MAXTIME;
}
}
TakeANumberMachine
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : TakeANumberMachine.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.abstracts.AbstractSmallTicket;
import com.itcast.smallticket.GeneralSmallTicket;
/**
* 取票的机器类
*
* @author Terry
* @date 2014-6-3
*
*/
public class TakeANumberMachine {
/**
* 单例设计模式
*/
private static TakeANumberMachine temp = new TakeANumberMachine();
private TakeANumberMachine(){}
public static TakeANumberMachine getTakeANumberMachine(){
return temp;
}
private MakingSmallTicketMachine1 generalTicketMachine1 = new MakingSmallTicketMachine1();
private MakingSmallTicketMachine1 fastTicketMachine1 = new MakingSmallTicketMachine1();
private MakingSmallTicketMachine1 vipTicketMachine1 = new MakingSmallTicketMachine1();
public synchronized AbstractSmallTicket getSmallTicket(AbstractCustomers a) {
switch (a.getType()) {
case GENERAL:
return generalTicketMachine1.makeGeneralTicket();
case FAST:
return fastTicketMachine1.makeGeneralTicket();
case VIP:
return vipTicketMachine1.makeGeneralTicket();
}
return null;
}
}
/**
* 内部类
*
* @author Terry
* @date 2014-6-3
*
*/
class MakingSmallTicketMachine1 {
Integer counter = 1;
AbstractSmallTicket ast;
synchronized AbstractSmallTicket makeGeneralTicket(){
ast = new GeneralSmallTicket();
ast.setNumber(counter);
counter ++;
return ast;
}
}
WaitingArea
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : WaitingArea.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast;
import java.util.ArrayList;
import java.util.List;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.enums.TypeInformation;
/**
* 等待区的类
*
* @author Terry
* @date 2014-6-3
*
*/
public class WaitingArea {
private WaitingArea(){}
private static WaitingArea waitingArea = new WaitingArea();
public static WaitingArea getWaitingArea(){
return waitingArea;
}
private List<AbstractCustomers> generalCustomers = new ArrayList<AbstractCustomers>();
private List<AbstractCustomers> fastCustomers = new ArrayList<AbstractCustomers>();;
private List<AbstractCustomers> VIPCustomers = new ArrayList<AbstractCustomers>();;
/**
*
* @param type
* @return
*/
public AbstractCustomers getCustomer(TypeInformation type) {
switch (type) {
case GENERAL:
if(generalCustomers.size() == 0){
return null;
}else{
AbstractCustomers temp = generalCustomers.remove(0);
// System.out.println(temp.getType());
return temp;
}
case FAST:
if(fastCustomers.size() == 0){
return null;
}else{
return fastCustomers.remove(0);
}
case VIP:
if(VIPCustomers.size() == 0){
return null;
}else{
return VIPCustomers.remove(0);
}
default:
return null;
}
}
public boolean addCustomer(AbstractCustomers a) {
switch (a.getType()) {
case GENERAL:
return generalCustomers.add(a);
case FAST:
return fastCustomers.add(a);
case VIP:
return VIPCustomers.add(a);
}
return false;
}
}
AbstractBusinessWindow
package com.itcast.abstracts;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.itcast.BusinessTimer;
import com.itcast.WaitingArea;
import com.itcast.constant.Constant;
import com.itcast.enums.TypeInformation;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : AbstractBusinessWindow.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 抽象业务窗口
*
* @author Terry
* @date 2014-6-3
*
*/
public abstract class AbstractBusinessWindow {
public Integer name;
public TypeInformation type;
protected BusinessTimer businessTimer;
protected AbstractCustomers custromer;
protected Constant constant = new Constant();
protected Random random = new Random();
public void start(final AbstractBusinessWindow abstractBusinessWindow){
Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
abstractBusinessWindow.acceptTheTask(abstractBusinessWindow);
}
},
1,
1,
TimeUnit.SECONDS);
}
public void acceptTheTask(AbstractBusinessWindow abstractBusinessWindow){
};
/**
* 处理普通业务
* @param a
*/
public void abstractProcessingBusiness(AbstractBusinessWindow abw,AbstractCustomers a) {
long beginTime = System.currentTimeMillis();
//System.out.println(beginTime);
long temp = (random.nextInt(constant.MAXTIME-constant.MINTIME)+1)+1000;
try {
Thread.sleep(temp);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime = System.currentTimeMillis() - beginTime;
System.out.println(abw.name + "号" + abw.type + "窗口为" + a.getTicket().getNumber() + "号" + a.getType() + "顾客服务,耗时" + endTime/1000 + "秒");
}
}
AbstractCustomers
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : AbstractCustomers.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.abstracts;
import com.itcast.TakeANumberMachine;
import com.itcast.constant.Constant;
import com.itcast.enums.TypeInformation;
/**
* 抽象客户
*
* @author Terry
* @date 2014-6-3
*
*/
public abstract class AbstractCustomers {
protected TypeInformation type;
protected AbstractSmallTicket ticket;
//取票机
protected TakeANumberMachine tanm;
protected Constant constant = new Constant();
public TypeInformation getType() {
return type;
}
public void setType(TypeInformation type) {
this.type = type;
}
public AbstractSmallTicket getTicket() {
return ticket;
}
public void setTicket(AbstractSmallTicket ticket) {
this.ticket = ticket;
}
/**
* 客户找取票机，取票
*/
private void goGetATicket(){
ticket = tanm.getSmallTicket(this);
}
/**
* 去等待区等待叫号
*/
private void goWaitingArea(){
constant.waitingArea.addCustomer(this);
System.out.println(ticket.getNumber() + "号" + type +"正在等待服务！");
}
/**
* 开始
*/
public void abstractStart() {
goGetATicket();
goWaitingArea();
}
}
AbstractSmallTicket
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : AbstractSmallTicket.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.abstracts;
/**
* 抽象小票
*
* @author Terry
* @date 2014-6-3
*
*/
public abstract class AbstractSmallTicket {
private Integer number;
public Integer getNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
}
FastBusinessWindow
package com.itcast.businesswindow;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.itcast.abstracts.AbstractBusinessWindow;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.enums.TypeInformation;
/**
* 办理快速业务的窗口也能办理普通业务
*
* @author Terry
* @date 2014-6-3
*
*/
public class FastBusinessWindow extends AbstractBusinessWindow {
public FastBusinessWindow(Integer i){
name = i;
type = TypeInformation.FAST;
}
public FastBusinessWindow(){
type = TypeInformation.FAST;
}
@Override
public void acceptTheTask(final AbstractBusinessWindow abstractBusinessWindow) {
// TODO Auto-generated method stub
System.out.println(abstractBusinessWindow.name +"号"+ abstractBusinessWindow.type + "窗口正在领取" + type +"的任务！");
if((custromer = constant.waitingArea.getCustomer(type)) != null){
abstractProcessingBusiness(custromer);
}else{
System.out.println("没有取到"+type+"任务，准备领取普通任务！");
GeneralBusinessWindow gbw = new GeneralBusinessWindow();
gbw.acceptTheTask(abstractBusinessWindow);
}
}
/**
* 处理快速业务
* @param a
*/
public void abstractProcessingBusiness(AbstractCustomers a) {
// TODO Auto-generated method stub
long beginTime = System.currentTimeMillis();
//System.out.println(beginTime);
long temp = (random.nextInt(constant.MAXTIME-constant.MINTIME)+1)+1000;
try {
Thread.sleep(constant.MINTIME);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime = System.currentTimeMillis() - beginTime;
System.out.println(name + "号" + type + "窗口为" + a.getTicket().getNumber() + "号" + a.getType() + "顾客服务,耗时" + endTime/1000 + "秒");
}
}
GeneralBusinessWindow
package com.itcast.businesswindow;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.itcast.abstracts.AbstractBusinessWindow;
import com.itcast.enums.TypeInformation;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : GeneralBusinessWindow.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 只能办理普通业务
*
* @author Terry
* @date 2014-6-3
*
*/
public class GeneralBusinessWindow extends AbstractBusinessWindow {
public GeneralBusinessWindow(Integer i){
name = i;
type = TypeInformation.GENERAL;
}
public GeneralBusinessWindow(){
type = TypeInformation.GENERAL;
}
@Override
public void acceptTheTask(final AbstractBusinessWindow abstractBusinessWindow) {
// TODO Auto-generated method stub
System.out.println(abstractBusinessWindow.name +"号"+ abstractBusinessWindow.type + "窗口正在领取普通的任务！");
if((custromer = constant.waitingArea.getCustomer(type)) != null){
abstractProcessingBusiness(abstractBusinessWindow,custromer);
}else{
System.out.println(abstractBusinessWindow.name +"号"+ abstractBusinessWindow.type + "没有取到普通任务，休息一会！");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
VIPBusinessWindow
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : VIPBusinessWindow.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.businesswindow;
import com.itcast.abstracts.AbstractBusinessWindow;
import com.itcast.enums.TypeInformation;
/**
* 办理VIP业务也能办理普通业务
*
* @author Terry
* @date 2014-6-3
*
*/
public class VIPBusinessWindow extends AbstractBusinessWindow {
public VIPBusinessWindow(Integer i){
name = i;
type = TypeInformation.VIP;
}
public VIPBusinessWindow(){
type = TypeInformation.VIP;
}
@Override
public void acceptTheTask(final AbstractBusinessWindow abstractBusinessWindow) {
// TODO Auto-generated method stub
System.out.println(abstractBusinessWindow.name +"号"+ abstractBusinessWindow.type + "窗口正在领取" + type +"的任务！");
if((custromer = constant.waitingArea.getCustomer(type)) != null){
abstractProcessingBusiness(abstractBusinessWindow,custromer);
}else{
System.out.println("没有取到"+type+"任务，领取普通任务！");
AbstractBusinessWindow gbw = new GeneralBusinessWindow();
gbw.acceptTheTask(abstractBusinessWindow);
}
}
}
Constant
package com.itcast.constant;
import com.itcast.TakeANumberMachine;
import com.itcast.WaitingArea;
/**
* 用来存储常量的类
*
* @author Terry
* @date 2014-6-3
*
*/
public class Constant {
public static final WaitingArea waitingArea = WaitingArea.getWaitingArea();
public static final TakeANumberMachine takeANumberMachine = TakeANumberMachine.getTakeANumberMachine();
public final int MAXTIME = 10000;
public final int MINTIME = 1000;
}
FastCustomers
package com.itcast.customer;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.constant.Constant;
import com.itcast.enums.TypeInformation;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : FastCustomers.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 前来办理快速业务的客户
*
* @author Terry
* @date 2014-6-3
*
*/
public class FastCustomers extends AbstractCustomers {
public FastCustomers(){
Constant cons = new Constant();
type = TypeInformation.FAST;
tanm = cons.takeANumberMachine;
}
}
GeneralCustomers
package com.itcast.customer;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.constant.Constant;
import com.itcast.enums.TypeInformation;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : GeneralCustomers.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 前来办理普通客户的业务
*
* @author Terry
* @date 2014-6-3
*
*/
public class GeneralCustomers extends AbstractCustomers {
public GeneralCustomers(){
Constant cons = new Constant();
type = TypeInformation.GENERAL;
tanm = cons.takeANumberMachine;
}
}
VIPCustomers
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : VIPCustomers.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.customer;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.constant.Constant;
import com.itcast.enums.TypeInformation;
/**
* 前来办理VIP业务的客户
*
* @author Terry
* @date 2014-6-3
*
*/
public class VIPCustomers extends AbstractCustomers {
public VIPCustomers(){
Constant cons = new Constant();
type = TypeInformation.VIP;
tanm = cons.takeANumberMachine;
}
}
TypeInformation
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : TypeInformation.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.enums;
/**
* 类型的枚举
*
* @author Terry
* @date 2014-6-3
*
*/
public enum TypeInformation {
GENERAL,FAST,VIP;
public String toString() {
switch (this) {
case GENERAL:
return "普通";
case FAST:
return "快速";
case VIP:
return "VIP";
}
return null;
};
}
Main
package com.itcast.main;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.itcast.abstracts.AbstractBusinessWindow;
import com.itcast.abstracts.AbstractCustomers;
import com.itcast.businesswindow.FastBusinessWindow;
import com.itcast.businesswindow.GeneralBusinessWindow;
import com.itcast.businesswindow.VIPBusinessWindow;
import com.itcast.customer.FastCustomers;
import com.itcast.customer.GeneralCustomers;
import com.itcast.customer.VIPCustomers;
/**
* 程序入口
*
* @author Terry
* @date 2014-6-3
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 开启普通窗口
*/
for (int i = 1; i < 5; i++) {
AbstractBusinessWindow abw1 = new GeneralBusinessWindow(i);
abw1.start(abw1);
}
/**
* 开启快速窗口
*/
AbstractBusinessWindow abw2 = new FastBusinessWindow(1);
abw2.start(abw2);
/**
* 开启VIP窗口
*/
AbstractBusinessWindow abw3 = new VIPBusinessWindow(1);
abw3.start(abw3);
/**
* 普通客户来了
*/
Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
AbstractCustomers ac = new GeneralCustomers();
ac.abstractStart();
}
},
1,
1,
TimeUnit.SECONDS);
/**
* 快速客户来了
*/
Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
AbstractCustomers ac = new FastCustomers();
ac.abstractStart();
}
},
1*3,
1*3,
TimeUnit.SECONDS);
/**
* VIP客户来了
*/
Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
AbstractCustomers ac = new VIPCustomers();
ac.abstractStart();
}
},
1*10,
1*10,
TimeUnit.SECONDS);
}
}
FastSmallTicket
package com.itcast.smallticket;
import com.itcast.abstracts.AbstractSmallTicket;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : FastSmallTicket.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 快速业务的小票
*
* @author Terry
* @date 2014-6-3
*
*/
public class FastSmallTicket extends AbstractSmallTicket {
}
GeneralSmallTicket
package com.itcast.smallticket;
import com.itcast.abstracts.AbstractSmallTicket;
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : GeneralSmallTicket.java
// @ Date : 2014/6/3
// @ Author :
//
//
/**
* 普通业务的小票
*
* @author Terry
* @date 2014-6-3
*
*/
public class GeneralSmallTicket extends AbstractSmallTicket {
}
VIPSmallTicket
//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : Untitled
// @ File Name : VIPSmallTicket.java
// @ Date : 2014/6/3
// @ Author :
//
//
package com.itcast.smallticket;
import com.itcast.abstracts.AbstractSmallTicket;
/**
* VIP业务的小票
*
* @author Terry
* @date 2014-6-3
*
*/
public class VIPSmallTicket extends AbstractSmallTicket {
}
程序到这里就写完了
相关知识点的解说
if语句和switch的区别？
1、作用都差不多的，但是swicth效率高
switch的数据类型只能是哪些？
经过在程序中用java中所有的数据类型做过的试验得出，switch中可以用的数据类型有：byte、char、short、int、枚举类型。（由于自动装箱和拆箱的关系他们的对象类型也可以用）
面向对象设计的一个重要原则
1、谁拥有数据，谁就对外提供操作这些数据的方法。
2、一段话中的名词一般可作为对象，动词一般可作为方法。
