面试题开发实战

最新推荐文章于 2024-01-02 15:41:41 发布

ghzhangfoxmail的博客

最新推荐文章于 2024-01-02 15:41:41 发布

阅读量837

点赞数 1

分类专栏： java学习笔记文章标签： Android java 面试题

本文链接：https://blog.csdn.net/ghzhangfoxmail/article/details/8711730

版权

java学习笔记专栏收录该内容

41 篇文章 0 订阅

订阅专栏

面试题开发实战

交通灯管理系统

1、项目需求

模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：

异步随机生成按照各个路线行驶的车辆。
例如：
由南向而来去往北向的车辆 ---- 直行车辆
由西向而来去往南向的车辆 ---- 右转车辆
由东向而来去往南向的车辆 ---- 左转车辆
。。。

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

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

具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。
注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。
随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。
不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

2、分析

举个例子。

有一辆从北向南开的汽车，当这辆车行驶到十字路口的时候，有三种选择：向西拐、向东拐、继续向南行驶。

所以，由此可以推测出，在十字路口，来自四个方向的车共有12种路线。

下面是示意图：

Road类表示路线，总共有12条路线，即系统中总共要产生12个Road实例对象。

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

为了统一编程模型，可以假设每条路线都有一个红绿灯对其进行控制。

其中在4个右拐弯一直可以通车，所以灯为常绿。

其他8条线路两两成对，可分4组。

所以，程序只需考虑图中标注了数字号的4条路线的控制灯的切换顺序，这4条路线相反方向的路线的控制灯跟随这4条路线切换，不必额外考虑。

即，路线1行驶完成后路线2行驶，依次路线3、4，然后循环路线1、2、3、4。

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

总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，设置这些灯为常亮状态，即永远不变黑。

另外8个灯，它们是两两成对的，可以归为4组，

所以，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，

因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，

Lamp类中还用一个变量来记住自己的下一个灯。

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

12个方向的灯的实例对象。

设计一个LampController类，它定时让当前的绿灯变红。

3、代码的编写

1）Road类

每个Road对象都有一个name成员变量来代表方向，有一个vehicles成员变量来代表方向上的车辆集合。
在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车（用一个“路线名_id”形式的字符串进行表示）。
在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，是则打印车辆集合和将集合中的第一辆车移除掉。

public class Road {
    private List<String> vechicles = new ArrayList<String>();

    private String name = null;

    public Road(String name) {
	this.name = name;

	// 模拟车辆不断随机上路的过程
	ExecutorService pool = Executors.newSingleThreadExecutor();
	pool.execute(new Runnable() {
	    public void run() {
		for (int i = 1; i < 1000; i++) {
		    try {
			Thread.sleep((new Random().nextInt(10) + 1) * 1000);
		    } catch (InterruptedException e) {
			e.printStackTrace();
		    }
		    vechicles.add(Road.this.name + "_" + i);
		}
	    }

	});

	// 每隔一秒检查对应的灯是否为绿，是则放行一辆车
	ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
	timer.scheduleAtFixedRate(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)
				+ " is traversing !");
		    }
		}

	    }
	}, 1, 1, TimeUnit.SECONDS);

    }
}

2）Lamp类

系统中有12个方向上的灯，在程序的其他地方要根据灯的名称就可以获得对应的灯的实例对象，综合这些因素，将Lamp类用java5中的枚举形式定义更为简单。

每个Lamp对象中的亮黑状态用lighted变量表示，选用S2N、S2W、E2W、E2N这四个方向上的Lamp对象依次轮询变亮，Lamp对象中还要有一个oppositeLampName变量来表示它们相反方向的灯，再用一个nextLampName变量来表示此灯变亮后的下一个变亮的灯。这三个变量用构造方法的形式进行赋值，因为枚举元素必须在定义之后引用，所以无法再构造方法中彼此相互引用，所以，相反方向和下一个方向的灯用字符串形式表示。

增加让Lamp变亮和变黑的方法：light和blackOut，对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象，这两个方法内部要让相反方向的灯随之变亮和变黑，blackOut方法还要让下一个灯变亮。
除了S2N、S2W、E2W、E2N这四个方向上的Lamp对象之外，其他方向上的Lamp对象的nextLampName和oppositeLampName属性设置为null即可，并且S2N、S2W、E2W、E2N这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null，以便防止light和blackOut进入死循环。

public enum Lamp {
    /* 每个枚举元素各表示一个方向的控制灯 */
    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) {
	    Lamp.valueOf(opposite).light();
	}
	System.out.println(name() + " lamp is green，下面总共应该有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;
    }
}

3）LampController类

整个系统中只能有一套交通灯控制系统，所以，LampController类最好是设计成单例。
LampController构造方法中要设定第一个为绿的灯。
LampController对象的start方法中将当前灯变绿，然后启动一个定时器，每隔10秒将当前灯变红和将下一个灯变绿。

public class LampController {
    private Lamp currentLamp;

    public LampController() {
	// 刚开始让由南向北的灯变绿;
	currentLamp = Lamp.S2N;
	currentLamp.light();

	/* 每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿 */
	ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
	timer.scheduleAtFixedRate(new Runnable() {
	    public void run() {
		System.out.println("来啊");
		currentLamp = currentLamp.blackOut();
	    }
	}, 10, 10, TimeUnit.SECONDS);
    }
}

4）MainClass类

用for循环创建出代表12条路线的对象。
接着再获得LampController对象并调用其start方法。

public class MainClass {

    /**
     * @param args
     */
    public static void main(String[] args) {

	/* 产生12个方向的路线 */
	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();
    }

}

银行业务调度系统

项目需求:

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方式展现程序运行结果.

对象分析

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

Ø 首先，经常在银行办理业务的人更有利于理解本系统，例如，我经常陪老婆跑银行，对银行的这个业务算是比较熟悉了，我知道每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以，我想到要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。

Ø 由于有三类客户，每类客户的号码编排都是完全独立的，所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

l 各类型客户在其对应窗口按顺序依次办理业务，准确地说，应该是窗口依次叫号。

Ø 各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

注: 普通窗口服务只普通客户, VIP窗口执行的服务和普通窗口的服务一样,只是VIP窗口优先给VIP客户服务,没客户就服务普通客户,快速窗口的服务不一样,且只服务对应的快速客户.

对象模型:

l NumberManager类

职责: 存储客户代码集合, 创建和管理客户号码.

Ø 定义一个用于存储上一个客户号码的成员变量 ------------------成员变量int lastNumber

Ø 用于存储所有等待服务的客户号码的队列集合--------------------成员变量List<Integer> queueNumber

Ø 定义一个产生新号码的方法-------------------------------------------成员方法int generateNewMananger()

Ø 获取马上要为之服务的号码的方法----------------------------------成员方法int fetchServiceNumber()

Ø 这两个方法被不同的线程操作了相同的数据，所以要进行同步(两方法加synchronized关键字)。

l NumberMachine类

职责: 创建和管理NumberManager类实例对象. (只需一个,可用单例生成此类)

Ø 定义三个成员变量分别指向三个NumberManager对象,分别表示普通、快速和VIP客户的号码管理器

-----------成员变量: 3个XXXnumberManager

Ø 定义三个对应的方法来返回这三个NumberManager对象--------成员方法: getXXXManager();

Ø 将NumberMachine类设计成单例。

l CustomerType枚举类

职责:表示客户类型, 三种类型客户用三个元素表示

Ø 系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。

Ø 重写toString方法，返回类型的中文名称。这是在后面编码时重构出来的，刚开始不用考虑。

l ServiceWindow类

职责:启动一个线程,提供模拟业务(处理客户号码)服务

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {……});//执行给定的命令

Ø 不停向对应的取号机取号,没有取到号的话等待一秒继续.

Ø 定义一个start方法，(内部启动一个线程，根据服务窗口的类别(枚举类型可用于Switch循环判定)分别循环调用三个不同的方法。) ------------------------------------------------------成员方法:void start();

Ø 定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息。

Ø 应该有个Id来标示6个窗口--------------------------------------------成员变量: int windowId;

Ø 应该有个变量来表示窗口类型(VIP,普通,快速)----------------------成员变量:CustomerType WindowType;

l MainClass类

职责: 创建类,启动线程,不停产生号码

Ø 用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。

Ø 接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

l Constants类

职责:提供定义不同服务时间的类常量,相当于配置文件

Ø 定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

原始代码:(见此段文档尾)

代码优化重写: (见此段文档尾)

1.主要重写窗口(ServiceWindow)中的服务代码------------方法三合一

原始代码中三种普通,快速,vip窗口需要三种对应的普通(commonService()), 快速(ExpressService()), vip(VIPService())的方法,而这些方法有很多相同和重复的地方,

完全可以将这三个方法合为一个方法(WindowService()),

WindowService(CustomerType customerType)

注意接收的参数是服务类型而不是窗口类型, 因为VIP窗口可以有两个服务类型VIP和common, 根据服务类型产生相应服务

在这个方法中, 原本三个有区别的地方进行判断来有区别的选择执行相关代码.VIP窗口执行WindowService()的时候如果没有拿到VIP客户代码,就会调用WindowService(CustomerType.COMMON),

但是调用前还判定这个窗口当前执行的是不是VIP服务,如果当前执行的是COMMON服务,再调用此方法就会死循环.

在计算服务时间的时候,判定如果当前服务类型是express,那么就用最小服务时间.

最后,还可以使用模板方法. 定义一个抽象类表示窗口服务,各种不同的服务方法实现这个方法类,各种服务方法的相同的地方封装到抽象类普通方法中, 不同的地方抽成抽象方法定义在抽象类中,让子类去继承实现.

//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

重写的代码优化(省略导入包):

常量类

public class Constants {
    public static int MAX_SERVICE_TIME=10000;
    public static int MIN_SERVICE_TIME=1000;
}
客户(或服务)类型
public enum CustomerType {
    COMMON,EXPRESS,VIP;
    public String toString(){
       switch (this) {
       case COMMON:
           return"普通";
       case VIP:
           return"VIP";
       case EXPRESS:
           return"快速";
       }
       return null;
    }
}

取号机

public class NumberManager {
    private    int lastNumber;
    private List<Integer>numbers=new LinkedList<Integer>();
    public synchronized void gengerateNumber(){
       numbers.add(lastNumber++);
    }
    public synchronized int fetchNumber(){
       if(numbers.size()==0)
           return 0;
       returnnumbers.remove(0);
    }
}

取号机的管理器

public class NumberMachine {
    private static NumberMachine numberMachine =new NumberMachine();
    private NumberManagercommonNumberManager = new NumberManager();
    private NumberManagerexpressNumberManager = new NumberManager();
    private NumberManagerVIPNumberManager = new NumberManager();
   
    public  NumberManagergetCommonNumberManager(){  return commonNumberManager; }
    public  NumberManagergetExpressNumberManager(){ return expressNumberManager; }
    public  NumberManagergetVIPNumberManager(){ return VIPNumberManager; }
    private NumberMachine(){ }
    public static NumberMachine getInstance(){    return numberMachine;}
}

窗口

public class ServiceWindow {
    private CustomerTypewindowType;
    private int id;
 
    public ServiceWindow(final CustomerType windowType,int id) {
       this.windowType = windowType;
       this.id = id;
       ExecutorService timer = Executors.newSingleThreadExecutor();
       timer.execute(new Runnable() {
           public void run() {
              while(true)
                  try {
                     windowService(windowType);
                  } catch (InterruptedException e) {e.printStackTrace();}
           }
       });
    }
    //windowService的参数是指什么样的服务类型  ,便于观看抛出异常
    public void windowService(CustomerType customerType) throwsInterruptedException {
       int number =0;
       //取和服务类型对应的那种号码
       switch (customerType) {
       case COMMON:
           number = NumberMachine.getInstance().getCommonNumberManager().fetchNumber();
           break;
       case EXPRESS:
           number = NumberMachine.getInstance().getExpressNumberManager().fetchNumber();
           break;
       case VIP:
           number = NumberMachine.getInstance().getVIPNumberManager().fetchNumber();
       }
       if (number != 0) {
           System.out.println(id+"号"+windowType+"窗口取得 "+number+"号"+customerType+"号码"+"正在进行任务");
           long beginTime = System.currentTimeMillis();
        //如果是Express类型,睡眠最小服务时间
           if(customerType==CustomerType.EXPRESS)
              Thread.sleep(Constants.MIN_SERVICE_TIME);
           else{//否则,睡眠用最小时间+随即服务时间
              long ServiceTime =new Random().nextInt(Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME)+1+Constants.MIN_SERVICE_TIME;
              Thread.sleep(ServiceTime);
           }
           long costTime = System.currentTimeMillis()-beginTime;
           System.out.println(id+"号"+windowType+"窗口为"+number+"号"+customerType+"号码服务完毕,用时: "+costTime+"豪秒");
       }
      else {//如果是VIP窗口并且当前是VIP服务的话还要执行common服务,如果不判定当前服务为VIP就执行common的话,会死循环
           if(windowType==CustomerType.VIP&&customerType==CustomerType.VIP)
              windowService(customerType.COMMON);
           else{//没取到号码,休息
              System.out.println("没有取得任务.休息一秒钟呀");
                  Thread.sleep(1000);     
           }
       }
    }
}

主函数类

public class MainClass {
    public static void main(String[] args) {
       NumberMachine numberMachine = NumberMachine.getInstance();
       for(int i =1;i<5;i++){
           new ServiceWindow(CustomerType.COMMON,i);
       }
       new ServiceWindow(CustomerType.EXPRESS,1);
       new ServiceWindow(CustomerType.VIP,1);
      
       ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
       timer.scheduleAtFixedRate(new Runnable(){
           public void run(){//common
              NumberMachine.getInstance().getCommonNumberManager().gengerateNumber();
           }
       }, 0, 1, TimeUnit.SECONDS);
      
       timer.scheduleAtFixedRate(new Runnable(){
           public void run(){//express
              NumberMachine.getInstance().getExpressNumberManager().gengerateNumber();
           }
       }, 0, 3, TimeUnit.SECONDS);
      
       timer.scheduleAtFixedRate(new Runnable(){
           public void run(){//VIP
              NumberMachine.getInstance().getVIPNumberManager().gengerateNumber();
           }
       }, 0, 6, TimeUnit.SECONDS);
      
    }
 
}

ghzhangfoxmail的博客

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试题开发实战

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------月薪7K面试题开发实战交通灯管理系统1、项目需求模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：异步随机生成按照各个路线行驶的车辆。例如：由南向而来去往北向的车辆 ---- 直行车辆由西向而来去往南向的车辆 ---- 右转
复制链接

扫一扫