Java交通燈系統

 

交通燈管理項目模擬了對十字路口交通燈的控制，通常在咱們生活中的十字路口是有人行道的，而此項目沒有考慮人行道。
具體需求以下：  
1.異步隨機生成按照各個路線行駛的車輛。  
        例如：  
        由南向而來去往北向的車輛 ---- 直行車輛  
        由西向而來去往南向的車輛 ---- 右轉車輛  
        由東向而來去往南向的車輛 ---- 左轉車輛

2.信號燈忽略黃燈，只考慮紅燈和綠燈

3.應考慮左轉車輛控制信號燈，右轉車輛不受信號燈控制。

4.具體信號燈控制邏輯與現實生活中普通交通燈控制邏輯相同，不考慮特殊狀況下的控制邏輯。  
        注：南北向車輛與東西向車輛交替放行，同方向等待車輛應先放行直行車輛然後放行左轉車輛。  
        每輛車經過路口時間爲1秒（提示：可經過線程Sleep的方式模擬）。隨機生成車輛時間間隔以及紅綠燈交換時間間隔自定，能夠設置。

5.每輛車經過路口的時間爲1秒 

六、隨機生成車輛的時間間隔，以及紅綠燈交換時間間隔自定，能夠設置。  
       項目編碼以前首先要理清項目的需求，在腦海中大體有一個項目的雛形，下面這個圖描述了項目中十字路口的狀況：
   

分析需求以及上面這個圖，能夠進行這樣的設計：  
一.每條路線上都會出現多輛車，路上要隨機增長車，在燈綠期間還要每秒鐘減小一輛車，項目中車沒有其餘的邏輯，能夠不把它提煉爲一個單獨的類，用字符串表示就能夠了.
    一、 設計一個Road類來表示路線，每一個Road對象表明一條路線，總共有12條路線，即系統中總共要產生12個Road實例對象。  
    二、 每條路線上隨機增長新的車輛，增長到一個集合中保存  
    三、 每條路線每隔一秒都會檢查控制本路線的燈是否爲綠，是則將本路線保存車的集合中的第一輛車移除，即表示車穿過了路口 

二.每條路線每隔一秒都會檢查控制本路線的燈是否爲綠，一個燈由綠變紅時，應該將下一個方向的燈變綠  
    一、設計一個Lamp類來表示一個交通燈，每一個交通燈都維護一個狀態：亮（綠）或不亮（紅），每一個交通燈要有變亮和變黑的方法，而且能返回本身的亮黑狀態。
    二、總共有12條路線，因此，系統中總共要產生12個交通燈。右拐彎的路線原本不受燈的控制，可是爲了讓程序採用統一的處理方式，故假設出有四個右拐彎的燈，只是這些燈爲常亮狀態，即永遠不變黑。
    三、除了右拐彎方向的其餘8條路線的燈，它們是兩兩成對的，能夠歸爲4組，因此，在編程處理時，只要從這4組中各取出一個燈，對這4個燈依次輪詢變亮，與這4個燈方向對應的燈則隨之一同變化，所以Lamp類中要有一個變量來記住本身相反方向的燈，在一個Lamp對象的變亮和變黑方法中，將對應方向的燈也變亮和變黑。每一個燈變黑時，都伴隨者下一個燈的變亮，Lamp類中還用一個變量來記住本身的下一個燈。
    四、不管在程序的什麼地方去得到某個方向的燈時，每次得到的都是同一個實例對象，因此Lamp類改用枚舉來作顯然具備很大的方便性，永遠都只有表明12個方向的燈的實例對象。
    五、設計一個LampController類，它定時讓當前的綠燈變紅。

在面向對象設計中有一步很關鍵，就是提煉出項目中有哪些類，這個須要根據需求與具體的設計，提煉時，能夠看需求文檔中出現的名詞。咱們初步設想一下有哪些對象：紅綠燈，紅綠燈的控制系統，汽車，路線。汽車看到本身所在路線對應的燈綠了就穿過路口嗎？不是，還須要看其前面是否有車，看前面是否有車，該問哪一個對象呢？該問路，路中存儲着車輛的集合，顯然路上就應該有增長車輛和減小車輛的方法了。再看題目，咱們這裏並不要體現車輛移動的過程，只是捕捉出車輛穿過路 口的過程，也就是捕捉路上減小一輛車的過程，因此，這個車並不須要單獨設計成爲一個對象，用一個字符串表示就能夠了。

面向對象設計把握一個重要的經驗：誰擁有數據，誰就對外提供操做這些數據的方法，這個被稱爲是專家模式。

此項目設計了4各種，分別是Road、Lamp、LampController、MainClass，下面就來看看這些類是如何設計的：  
Road類  
    一、 每一個Road對象都有一個name成員變量來表明方向，有一個vehicles成員變量來表明方向上的車輛集合。  
    二、 在Road對象的構造方法中啓動一個線程每隔一個隨機的時間向vehicles集合中增長一輛車（用一個「路線名_id」形式的字符串進行表示）。  
    三、 在Road對象的構造方法中啓動一個定時器，每隔一秒檢查該方向上的燈是否爲綠，是則打印車輛集合和將集合中的第一輛車移除掉。  
這個類中須要啓動一個線程以及定時器，啓動線程推薦使用Java5提供的線程庫，性能較好些，提供了線程池，線程池是一上來就搞出來許多線程，放在那，當有任務交給他時，從池中找出一個空閒的去執行這個任務，Executors是一個線程工具類，提供了大量的對線程進行支持的靜態方法。  
Road類代碼以下：

package heimablog.traffic;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 每一個Road對象表明一條路線，總共有12條路線，即系統中總共要產生12個Road實例對象。 每條路線上隨機增長新的車輛，增長到一個集合中保存。
 * 每條路線每隔一秒都會檢查控制本路線的燈是否爲綠，是則將本路線保存車的集合中的第一輛車移除，即表示車穿過了路口。
 * @author adanac
 */
public class Road {

	//車並不須要定義一個實體類，將車以字符串的形式定義到數組中便可
	//經過分析車的特色，車有增長和減小的方法，因此鏈表結構是符合車的存儲特色的  
	//爲何不寫ArrayList集合呢 由於面向接口編程  
	/*接口 List<E> 
	全部超級接口：  
	Collection<E>, Iterable<E>  
	全部已知實現類（部分）：  
	AbstractList, ArrayList, AttributeList, LinkedList, Vector*/
	
	private List<String> vehicls = new ArrayList<String>();

	private String name;

	//在構造方法中不斷的建立車
	public Road(String name) {
		this.name = name;

		//線程庫,使用線程庫來建立一個線程，至關於一個線程池  
		ExecutorService pool = Executors.newSingleThreadExecutor();
		
		//至關於new一個Runnable的實現類對象 
		pool.execute(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i < 8000; i++) {
					try {
						Thread.sleep(1000 * (new Random().nextInt(10) + 1));//sleep隨機數，隨機值1~10 
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					vehicls.add(Road.this.name + "_" + i);//內部類訪問外部類,能夠在構造函數的參數String前加final,也可使用外部類名.this.變量名  
				}
			}
		});

		//定時器每隔1s檢查綠燈是否變亮  
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				//定義變量lighted判斷當前線路的燈是不是綠燈
				boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
				if (lighted) {
					//若是是綠燈而且檢查到路上有車，則放行第一輛車
					if (vehicls.size() > 0) {
						System.out.println(vehicls.remove(0));
					}
				}
			}
		}, 1, 1, TimeUnit.SECONDS);
	}
}

/**
 *Road類中使用了Java多線程：類Executors主要的工廠方法，也是建立線程池的方法，建立一個單線程化的Executor)：newSingleThreadExecutor() 
 *建立一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。
 *可保證順序地執行各個任務，而且在任意給定的時間不會有多個線程是活動的。
 */

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進入死循環。
Lamp類代碼以下：

package heimablog.traffic;

/** 
 * 每一個Lamp元素表明一個方向上的燈，總共有12個方向，全部總共有12個Lamp元素。
 * 有以下一些方向上的燈,每兩個造成一組，一組燈同時變綠或變紅. 
 * 程序代碼只須要控制每組燈中的一個燈便可： 
 * s2n,n2s     
 * s2w,n2e 
 * e2w,w2e 
 * e2s,w2n 
 * s2e,n2w 
 * e2n,w2s 
 * 上面最後兩行的燈是虛擬的，因爲從南向東和從西向北、以及它們的對應方向不受紅綠燈的控制， 
 * 因此，能夠假想它們老是綠燈。 
 * @author adanac
 */  
public enum Lamp {

	//定義12條線路,每一個枚舉元素各表示一個方向的控制燈
	//關鍵在於模擬右轉彎的燈始終是亮着的，以統一模型
	//每一個枚舉元素各表示一個方向的控制燈 
	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);
	
	/* 與當前燈同時爲綠的對應方向(爲了不傳遞的錯誤，咱們將燈Lamp變爲字符串，傳遞對應燈的名字字符串) */  
	private String opposite;
	/* 當前燈變紅時下一個變綠的燈 */  
	private String next;
	/* 當前燈是否爲綠 */
	private boolean lighted;
	private Lamp(String opposite, String next, boolean lighted) {
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}
	
	//定義一個返回燈是否亮着的方法
	public boolean isLighted(){
		return lighted;
	}
	
	//讓燈變綠，而且讓對應方向的燈也變綠
	public void light(){
		this.lighted = true;
		if (opposite != null) {
			Lamp.valueOf(opposite).light();
		}
		System.out.println(name() + " 燈亮了,有6個方向的車在移動");
	}
	
	// 讓燈變紅，而且讓對應方向的燈也變紅，也要讓下一個方向的燈變綠  
	public Lamp blackOut(){
		this.lighted = false;
		if (opposite != null) {
			System.out.println("綠燈由" + name() +" -----> " + next);
			Lamp.valueOf(opposite).blackOut();
		}
		
		Lamp nextLamp = null;
		//定義一個避免死循環的解決辦法
		if (next != null) {
			nextLamp = Lamp.valueOf(next);
			nextLamp.light();
		}
		return nextLamp;
	}
}

LampController類
    一、整個系統中只能有一套交通燈控制系統，因此，LampController類最好是設計成單例。
   二、LampController構造方法中要設定第一個爲綠的燈。
   三、LampController對象的start方法中將當前燈變綠，而後啓動一個定時器，每隔10秒將當前燈變紅和將下一個燈變綠。
LampController代碼以下：

package heimablog.traffic;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

//定義一個燈的控制器  
public class LampController {

	//定義一個變量：當前的燈
	private Lamp currentlLamp;
	//定義構造方法， 構造方法上來 應該讓某一個燈變綠  
	public LampController() {
		currentlLamp = Lamp.S2N;
		currentlLamp.light();
		
		//作個定時器，讓每隔10s綠燈變紅燈,並讓下一個方向的燈變綠
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(new Runnable() {
			
			@Override
			public void run() {
				currentlLamp = currentlLamp.blackOut();
			}
		}, 10, 10, TimeUnit.SECONDS);
	}
}

MainClass類
    一、用for循環建立出表明12條路線的對象。
   二、接着建立出LampController對象，並調用其start方法。
代碼以下：

package heimablog.traffic;

public class MainClass {

	public static void main(String[] args) {

		//建立12條路線的對象
		String[] directions = {
				"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個方向的車在移動
S2E_1 is travelling!
E2N_1 is travelling!
W2S_1 is travelling!
N2W_1 is travelling!
N2S_1 is travelling!
N2S_2 is travelling!
W2S_2 is travelling!
S2N_1 is travelling!
N2W_2 is travelling!
N2W_3 is travelling!
綠燈由S2N -----> S2W
N2E 燈亮了,有6個方向的車在移動
S2W 燈亮了,有6個方向的車在移動
N2E_1 is travelling!
S2W_1 is travelling!
S2E_2 is travelling!
E2N_2 is travelling!
N2E_2 is travelling!
N2E_3 is travelling!
N2W_4 is travelling!
W2S_3 is travelling!
S2E_3 is travelling!
S2W_2 is travelling!
E2N_3 is travelling!
N2E_4 is travelling!
N2E_5 is travelling!
E2N_4 is travelling!
S2E_4 is travelling!
N2W_5 is travelling!
綠燈由S2W -----> E2W
W2E 燈亮了,有6個方向的車在移動
E2W 燈亮了,有6個方向的車在移動
E2W_1 is travelling!
W2E_1 is travelling!

總結：

• 成功的模擬了對交通燈的控制，這個項目中最重要的就是，分析業務邏輯，畫出相應的分析圖：總共有12條路線，爲了統一編程模型，假設每條路線都有一個紅綠燈對其進行控制，右轉彎的4條路線的控制燈假設稱爲常綠狀態。
• 另外，其餘的8條線路是兩兩成對的，能夠歸爲4組，因此程序只需考慮圖中標註了數字號的4條路線的控制燈的切換順序，這4條路線相反方向的路線的控制燈跟隨這4條路線切換，沒必要額外考慮。沒有這一步這個項目就無從入手了，這也告訴咱們作一個項目以前，要理解需求，理清思路，讓項目在大腦中有一個大體的雛形，而後再去編碼，這樣一步一步的才能成功！