java实例

        这一篇主要说一下两个程序示例，这两道题对于我们所学知识的综合利用有很大的帮助，对于很多知识点我们大多都是处于一知半解的状态，知道有这么回事，但是真正的开发利用中就是不知道如何下手，还有一些知识点是没有接触过，通过这两道题把所学的知识点串一下，更重要的是培养一种灵活运用所学知识的能力和学习的态度与方法。

一．交通灯管理系统

1.交通灯管理系统的要求

这个交通灯管理系统要求异步随机生成按照各个路线行驶的车辆。

例如：

       由南向而来去往北向的车辆---- 直行车辆

       由西向而来去往南向的车辆 ---- 右转车辆

       由东向而来去往南向的车辆 ---- 左转车辆

       。。。。。。

        ①   信号灯忽略黄灯，只考虑红灯和绿灯。

        ②   应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

        ③   具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

        注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

        ④   每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

        随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

        不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

2.系统分析

      我们按照要求并联想现实生活中的实际路口来思考，凭借大多数人的大脑是无法在脑海中构建这个交通灯的全部情况，所以我们要通过画图来说明：

        通过这张示意图我们可以看出来总共有12条路线，为了统一编程模型，可以假设每条路线都有一个红绿灯对其进行控制，右转弯的4条路线的控制灯可以假设称为常绿状态，另外，其他的8条线路是两两成对的（方向相反），可以归为4组，所以，程序只需考虑图中标注了数字号的4条路线的控制灯的切换顺序，这4条路线其所对应的相反方向的路线的控制灯跟随这4条路线切换，不必额外考虑。

        也就是说第一条路线是由南向北行驶，我们用S2N表示，与他是一组的是N2S，因为他们虽然方向不同，但是可以被同状态的红绿灯控制，第二条线路是S2W，与他相对的是N2E，依次分析这个交通灯管理系统中总共有4条线路被红绿灯控制。

        根据我们现实中的情况当①线路绿灯后，S2N和N2S方向上的车启动，当①红灯后，②线路绿灯，然后③线路，最后④线路，④线路红灯之后①线路接着绿灯。

3.面相对象的需求与分析

        根据需求我们来分析一下本系统中需要用到哪些对象，红绿灯控制系统，首先要有车，然后车得用灯控制，车还得有行进的路线，汽车看到自己所在路线对应的灯绿了就能穿过路口吗？不是，还需要看其前面是否有车，看前面是否有车，就需要一个新的对象——路，路中存储着车辆的集合，显然路上就应该有增加车辆和减少车辆的方法了。再看题目，我们这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，也就是捕捉路上减少一辆车的过程，所以，这个车并不需要单独设计成为一个对象，用一个字符串表示就可以了。

每条路线上都会出现多辆车，路线上要随机增加新的车，在灯绿期间还要每秒减少一辆车。

（1）设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。

        1>每条路线上随机增加新的车辆，增加到一个集合中保存。

        2>每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。

        3>每条路线每隔一秒都会检查控制本路线的灯是否为绿，一个灯由绿变红时，应该将下一个方向的灯变绿。

代码如下：

public class Road {//建立集合用来存储车（字符串）private List<String> vechicles = new ArrayList<String>();//每条路线都有着自己的名字，我们通过构造函数接收他的名字private String name =null;//在一个Road对象实例化的过程中开启一条线程来产生车辆public Road(String name){this.name = name;/*模拟车辆不断随机上路的过程 * 利用线程池来创建新的线程，在新的线程中添加车辆 * */ExecutorService pool = Executors.newSingleThreadExecutor();pool.execute(new Runnable(){public void run(){//每条路上产生49辆车for(int i=1;i<50;i++){//随机暂停几秒后此道路添加车辆try {Thread.sleep((new Random().nextInt(10) + 1) * 1000);} catch (InterruptedException e) {e.printStackTrace();}//内部类访问外部类的成员变量，可以加this，但因为局部变量名也为name，所以使用下面格式vechicles.add(Road.this.name + "_" + i);}}});/*每隔一秒检查对应的灯是否为绿，是则放行一辆车 * 利用调度池来构建一个定时器，每隔1秒来检测这条线对应的灯 * */ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);timer.scheduleAtFixedRate(//定时器要做的事情封装进Runnable当中new Runnable(){public void run(){//如果集合内有车，那么判断灯的状态if(vechicles.size()>0){boolean lighted = Lamp.valueOf(Road.this.name).isLighted();if(lighted){//集合在删除元素时会把该元素返回来System.out.println(vechicles.remove(0) + "  号车通过路口!");}}}},1,//过多少时间量之后去做Runnable封装的事情1,//做完Runnable封装的事情之后再过多少时间量重新去做TimeUnit.SECONDS);//单位为秒}}

（2）设计一个Lamp类来表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

        1>总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。

        2>除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯,除去这两个变量之外，还要有一个变量记录自己的状态。

        注意：无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象，所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

首先设计Lamp类来描述灯：

/* * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。 * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以， * 程序代码只需要控制每组灯中的一个灯即可： * s2n,n2s     * s2w,n2e * e2w,w2e * e2s,w2n * s2e,n2w * e2n,w2s * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制， * 所以，可以假想它们总是绿灯。 */public enum Lamp {/*每个枚举元素各表示一个方向的控制灯，每一个枚举元素在初始化的时候要接收3个参数 * 1.相反方向的灯2.下一个要点亮的灯3.灯的状态*/S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),/*下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计！*/N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),/*由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯*/S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);//使用传递字符串的方式来获得灯的名字private Lamp(String opposite,String next,boolean lighted){this.opposite = opposite;this.next = next;this.lighted = lighted;}/*当前灯的状态*/private boolean lighted;/*与当前灯同时为绿的对应方向*/private String opposite;/*当前灯变红时下一个变绿的灯*/private String next;//对外提供方法获取灯的状态public boolean isLighted(){return lighted;}/** * 某个灯变绿时，它对应方向的灯也要变绿 */public void light(){this.lighted = true;if(opposite != null){//valueOf方法可以通过字符串获取到其对应的对象Lamp.valueOf(opposite).light();}System.out.println(name() + " 灯变绿了，下面总共应该有6个方向能看到汽车穿过！");}/** * 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿 * @return 下一个要变绿的灯 */public Lamp blackOut(){//当前灯变红this.lighted = false;//对应的灯也变红if(opposite != null){Lamp.valueOf(opposite).blackOut();}//下一个灯变绿Lamp nextLamp= null;if(next != null){nextLamp = Lamp.valueOf(next);System.out.println("绿灯从" + name() + "-------->切换为" + next);nextLamp.light();}return nextLamp;}}

设计一个LampController类，用来管理灯对象，它定时让当前的绿灯变红。

/* * 定义灯的控制器，在Lamp中只是定义了灯的属性和方法，而如何控制灯 * 则由灯控制器来操作 * */public class LampController {//首先要定义成员变量表征当前的灯private Lamp currentLamp;//定义控制灯的方法public LampController(){//获取由南向北的灯currentLamp = Lamp.S2N;//S2N变绿，这样绿的是两个灯，北到南也绿了currentLamp.light();/*每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿 * 使用定时器 * */ ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);timer.scheduleAtFixedRate(new Runnable(){public void run(){//把当前灯变黑，blackOut方法把下一个灯也变绿了currentLamp = currentLamp.blackOut();}},10,10, TimeUnit.SECONDS);}}

我们所有的对象都已经创建好了，现在我们创建主线程：

public class MainClass {public static void main(String[] args) {/*产生12个方向的路线，一个个new太麻烦交给for循环去做*/String [] directions = new String[]{"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};for(int i=0;i<directions.length;i++){new Road(directions[i]);}/*产生整个交通灯系统*/new LampController();}}

运行主线程，就可以得到运行结果：

N2S 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2N 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

N2S_1  号车通过路口!

W2S_1  号车通过路口!

W2S_2  号车通过路口!

W2S_3  号车通过路口!

N2S_2  号车通过路口!

W2S_4  号车通过路口!

S2N_1  号车通过路口!

S2E_1  号车通过路口!

E2N_1  号车通过路口!

N2W_1  号车通过路口!

E2N_2  号车通过路口!

绿灯从S2N-------->切换为S2W

N2E 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2W 灯变绿了，下面总共应该有6个方向能看到汽车穿过！

S2W_1  号车通过路口!

N2E_1  号车通过路口!

S2W_2  号车通过路口!

N2E_2  号车通过路口!

N2W_2  号车通过路口!

S2E_3  号车通过路口!

W2S_5  号车通过路口!

S2W_4  号车通过路口!

S2E_4  号车通过路口!

N2W_3  号车通过路口!

N2E_4  号车通过路口!

E2N_3  号车通过路口!

。。。。。。

由于是随机的，所以每次运行结果是不一致的，但是运行的状态就是这个样子。结果是我们一步一步做出来的，总结一下，这个红绿灯控制系统中我们使12条路线对应12个红绿灯，统一了系统模型，而每一个灯在系统中的对象都是唯一的，使用枚举，我们又通过分析发现只要控制4条路线就可以让这个交通灯系统运行，简化了代码的书写。通过这个示例我觉得我们在编程的时候首先要明确需求，通过需求来分析要使用哪些对象，然后去构建对象和使用对象。

二．银行业务调度系统

1.银行业务调度系统的要求

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

        银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。

        有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

        异步随机生成各种类型的客户，生成各类型用户的概率比例为：

        VIP客户 ：普通客户 ：快速客户 =  1 ：6 ：3。

        客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值

        各类型客户在其对应窗口按顺序依次办理业务。

        当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

        随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。

2.面向对象的分析和设计

有三种对应类型的客户：VIP客户，普通客户，快速客户 ，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务 。

（1）首先，我们应该明确银行用来确定客户是通过一个取号机器来明确的，所以我们就想到需要有一个号码管理器对象，由于有三类客户，每类客户的号码编排都是完全独立的，所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

（2）各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

我们通过示意图来了解一下这个系统的构成：

 

我们来看一下代码的设计：定义号码管理器类：

/* * 定义号码管理器类，这个类中有产生新号码的方法和反馈给窗口号码的方法 * 注意点： * 1. 由于产生的新号码并不是马上就被窗口获取到，所以每产生一个号码都需要存储 * 起来等待窗口的调度，在此我们使用集合来存储产生的号码 * 2.产生新号码和获取号码是不同的线程，多线程访问公有资源要加锁。 * */public class NumberManager {private int lastNumber = 0;private List queueNumbers = new ArrayList();//产生新的号码public synchronized Integer generateNewNumber(){queueNumbers.add(++lastNumber);return lastNumber;}//定义取得方法public synchronized Integer fetchNumber(){if(queueNumbers.size()>0){return (Integer)queueNumbers.remove(0);}else{return null;}}}

然后设计取号器：

/* * 定义取号器类，这个类可以生成3个号码管理器对象 * 由于取号器在银行系统中只有一个所以要设计成单例设计模式 * */public class NumberMachine {//私有本类构造函数，不能new对象private NumberMachine(){}//new一个本类对象以保证此类对象的唯一性private static NumberMachine instance = new NumberMachine();//对外提供方法将本类对象返回public static NumberMachine getInstance(){return instance;}//定义三个成员变量分别对应3个号码管理器对象private NumberManager commonManager = new NumberManager();//普通客户private NumberManager expressManager = new NumberManager();//快速客户private NumberManager vipManager = new NumberManager();//VIP客户public NumberManager getCommonManager() {return commonManager;}public NumberManager getExpressManager() {return expressManager;}public NumberManager getVipManager() {return vipManager;}}

设计窗口：

public class ServiceWindow {private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");private CustomerType type = CustomerType.COMMON;private int number = 1;public CustomerType getType() {return type;}public void setType(CustomerType type) {this.type = type;}public void setNumber(int number){this.number = number;}//定义方法开启一条线程，这条线程执行取号的动作public void start(){Executors.newSingleThreadExecutor().execute(new Runnable(){public void run(){//下面这种写法的运行效率低，最好是把while放在case下面while(true){switch(type){case COMMON:commonService();break;case EXPRESS:expressService();break;case VIP:vipService();break;}}}});}//为普通客户服务private void commonService(){String windowName = "第" + number + "号" + type + "窗口";System.out.println(windowName + "开始获取普通任务!");//获取到普通客户所对应的号码管理器中的等待号Integer serviceNumber = NumberMachine.getInstance().getCommonManager().fetchNumber();if(serviceNumber != null ){System.out.println(windowName + "开始为第" + serviceNumber + "号普通客户服务");//在外部定义了常量类提供最大服务时间和最小时间int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;//模拟客户的服务时间，利用Random随机生成最大值10秒和最小值1秒之间的任意秒int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;try {Thread.sleep(serviceTime);} catch (InterruptedException e) {e.printStackTrace();}//当线程sleep之后醒来打印这个时间System.out.println(windowName + "完成为第" + serviceNumber + "号普通客户服务，总共耗时" + serviceTime/1000 + "秒");}else{System.out.println(windowName + "没有取到普通任务，正在空闲一秒");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}//为快速客户服务private void expressService(){//获取快速客户号码管理器反馈的号码Integer serviceNumber = NumberMachine.getInstance().getExpressManager().fetchNumber();String windowName = "第" + number + "号" + type + "窗口";System.out.println(windowName + "开始获取快速任务!");if(serviceNumber !=null){System.out.println(windowName + "开始为第" + serviceNumber + "号快速客户服务");//服务时间就是最小值1秒int serviceTime = Constants.MIN_SERVICE_TIME;try {Thread.sleep(serviceTime);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(windowName + "完成为第" + serviceNumber + "号快速客户服务，总共耗时" + serviceTime/1000 + "秒");}else{//当没有获取到快速客户时切换为普通客户System.out.println(windowName + "没有取到快速任务！");commonService();}}private void vipService(){//获取VIP客户的号码管理器反馈的号码Integer serviceNumber = NumberMachine.getInstance().getVipManager().fetchNumber();String windowName = "第" + number + "号" + type + "窗口";System.out.println(windowName + "开始获取VIP任务!");if(serviceNumber !=null){System.out.println(windowName + "开始为第" + serviceNumber + "号VIP客户服务");int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;try {Thread.sleep(serviceTime);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(windowName + "完成为第" + serviceNumber + "号VIP客户服务，总共耗时" + serviceTime/1000 + "秒");}else{//当没有获取到VIP客户时切换为普通客户System.out.println(windowName + "没有取到VIP任务！");commonService();}}}

在窗口的设计中我们使用到了一个枚举来获取三种类型的窗口：

public enum CustomerType {COMMON,EXPRESS,VIP;//根据定义的枚举对象名返回相应的中文表现形式public String toString(){String name = null;switch(this){case COMMON:name = "普通";break;case EXPRESS:name = "快速";break;case VIP:name = name();break;}return name;}}

我们使用到了一些常量，我们把他单独封装成一个类：

/* * 定义常量类 * */public class Constants {public static int MAX_SERVICE_TIME = 10000; //每个客户服务最长时间10秒！public static int MIN_SERVICE_TIME = 1000; //每个客户服务最短时间1秒！}

最后设计主线程：

public class MainClass {private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");public static void main(String[] args) {//产生4个普通窗口for(int i=1;i<5;i++){ServiceWindow window =  new ServiceWindow();window.setNumber(i);window.start();}//产生1个快速窗口ServiceWindow expressWindow =  new ServiceWindow();expressWindow.setType(CustomerType.EXPRESS);expressWindow.start();//产生1个VIP窗口ServiceWindow vipWindow =  new ServiceWindow();vipWindow.setType(CustomerType.VIP);vipWindow.start();//普通客户拿号Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable(){public void run(){//产生新的普通客户Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();/** * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来， * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。 *///logger.info("第" + serviceNumber + "号普通客户正在等待服务！");System.out.println("第" + serviceNumber + "号普通客户正在等待服务！");}},0,//马上就有客户产生Constants.COMMON_CUSTOMER_INTERVAL_TIME,TimeUnit.SECONDS);//快速客户拿号Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable(){public void run(){Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");}},0,Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,TimeUnit.SECONDS);//VIP客户拿号Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable(){public void run(){Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");}},0,Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, TimeUnit.SECONDS);}}

这MainClass类中使用到了一些常量，我们把他加到常量类Constants中：

public class Constants {public static int MAX_SERVICE_TIME = 10000; //每个客户服务最长时间10秒！public static int MIN_SERVICE_TIME = 1000; //每个客户服务最短时间1秒！/*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以， * 1秒钟产生一个普通客户比较合理，通过让这个变量乘以不同值来控制3种客户间的比例关系*/public static int COMMON_CUSTOMER_INTERVAL_TIME = 1; }

这样我们的银行业务调度系统就设计完成了，我们运行一下可以看到，首先6的窗口都开始工作，准备获取其对应的任务，这个时候还没有客户被创建出来所以他们会等待一秒，在cpu不断的执行中各种类型的客户被创建出来了，就去对应的窗口执行，快速窗口和Vip窗口在没有对应的客户等待的情况下去为普通客户服务，这就是我们这个程序的运行结果。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------