Merlin

有可能在閃躲炮彈和執行精確攻擊的演練中學會繼承、多態性、事件處理以及內部類這些內容嗎？Robocode 這個游戲即將為全世界的 Java 開發者實現這個愿望，它把游戲風潮變成了教學工具，人們對它的上癮程度令人吃驚。請跟隨 Sing Li 一起拆解 Robocode，同時著手建造屬于自己的、定制的、小而精悍的戰斗機器。

Robocode 是一個很容易使用的機器人戰斗仿真器，可以在所有支持 Java 2 的平臺上運行。您創建一個機器人，把它放到戰場上，然后讓它同其他開發者們創建的機器人對手拼死戰斗到底。Robocode 里有一些預先做好的機器人對手讓你入門，但一旦您不再需要它們，就可以把您自己創建的機器人加入到正在世界范圍內形成的某個聯盟里去和世界最強手對陣。

每個 Robocode 參加者都要利用 Java 語言元素創建他或她的機器人，這樣就使從初學者到高級黑客的廣大開發者都可以參與這一娛樂活動。初級的 Java 的開發者們可以學習一些基礎知識：調用 API 代碼、閱讀 Javadoc、繼承、內部類、事件處理等等。高級開發者們可以在構建“最優品種”的軟件機器人全球競賽中提高他們的編程技巧。在本文中，我們將介紹 Robocode，并指導您從構建您平生第一個 Robocode 機器人開始征服世界。我們還將看一下迷人的“后臺”機制，正是它使得 Robocode 起作用。

下載并安裝 Robocode

Robocode 是 Mathew Nelson 的智慧之作，他是 IBM Internet 部門 Advanced Technology 的軟件工程師。請首先訪問 IBM alphaWorks Robocode 頁面。在這個頁面上，您可以找到 Robocode 系統最新的可執行文件。這個分發包是一個自包含的安裝文件，在下載該分發包之后，您就可以使用下面的命令行在您的系統上安裝這個軟件包（當然，我們假定您的機器上已經預安裝了 Java VM（JDK 1.3.x））：

java -jar robocode-setup.jar

?在安裝過程中，Robocode 將問您是否要使用這個外部的 Java VM 來編譯機器人。您也可以選擇使用作為 Robocode 分發包一部分而提供的 Jikes 編譯器。

安裝完成后，您可以通過 shell 腳本（robocode.sh）、批處理文件（robocode.bat）或桌面上的圖標來啟動 Robocode 系統。此時，戰場將會出現。在此，您可以通過菜單調用 Robot Editor 和 compiler。

回頁首

Robocode 系統組件

當您激活 Robocode 時，將看到兩個相關的 GUI 窗口，這兩個窗口構成了 Robocode 的 IDE：

• 戰場
• Robot Editor

圖 1 展示了處于工作狀態的戰場和 Robot Editor。

戰場是機器人之間進行戰斗直至分出勝負的場地。主要的仿真引擎被置于其中，并且允許您在這里創建戰斗、保存戰斗以及打開新建的或現有的戰斗。通過界面區域內的控件，您可以暫停或繼續戰斗、終止戰斗、消滅任何機器人個體或獲取任何機器人的統計數據。此外，您可以在此屏幕上激活 Robot Editor。

Robot Editor 是一個定制的文本編輯器，它可以用于編輯生成機器人的 Java 源文件。在它的菜單里集成了 Java 編譯器（用于編譯機器人代碼）以及定制的 Robot 打包器。由 Robot Editor 創建并成功編譯的所有機器人都會處于戰場上一個部署就緒的位置。

Robocode 里的每個機器人都由一個或多個 Java 類構成。這些類可以被壓縮成一個 JAR 包。為此，Robocode 的最新版本提供了一個可以在戰場 GUI 窗口中激活的“Robot Packager”。

回頁首

對 Robocode 機器人的詳細分析

在寫這篇文章時，Robocode 機器人是一個圖形化的坦克。圖 2 是一個典型的 Robocode 機器人的圖解。

請注意，機器人有一門可以旋轉的炮，炮上面的雷達也是可以旋轉的。機器人坦克車（Vehicle）、炮（Gun）以及雷達（Radar）都可以單獨旋轉，也就是說，在任何時刻，機器人坦克車、炮以及雷達都可以轉向不同的方向。缺省情況下，這些方向是一致的，都指向坦克車運動的方向。

回頁首

Robot 命令

Robocode 機器人的命令集都收錄在 Robocode API Javadoc 中。您將會發現這些命令都是 robocode.Robot 類的公共方法。在這一部分，我們將分類討論每個可用的命令。

移動機器人、炮和雷達

讓我們從移動機器人及其裝備的基本命令開始：

• turnRight(double degree) 和 turnLeft(double degree) 使機器人轉過一個指定的角度。
  
• ahead(double distance) 和 back(double distance) 使機器人移動指定的像素點距離；這兩個方法在機器人碰到墻或另外一個機器人時即告完成。
  
• turnGunRight(double degree) 和 turnGunLeft(double degree) 使炮可以獨立于坦克車的方向轉動。
  
• turnRadarRight(double degree) 和 turnRadarLeft(double degree) 使炮上面的雷達轉動，轉動的方向也獨立于炮的方向（以及坦克車的方向）。

這些命令都是在執行完畢后才把控制權交還給程序。此外，轉動坦克車的時候，除非通過調用下列方法分別指明炮（和雷達）的方向，否則炮（和雷達）的指向也將移動。

• setAdjustGunForRobotTurn(boolean flag) ：如果 flag 被設置成 true，那么坦克車轉動時，炮保持原來的方向。
  
• setAdjustRadarForRobotTurn(boolean flag) ：如果 flag 被設置成 true，那么坦克車（和炮）轉動時，雷達會保持原來的方向。
  
• setAdjustRadarForGunTurn(boolean flag) ：如果 flag 被設置成 true，那么炮轉動時，雷達會保持原來的方向。而且，它執行的動作如同調用了 setAdjustRadarForRobotTurn(true) 。

獲取關于機器人的信息

有許多方法可以得到關于機器人的信息。下面簡單列舉了常用的方法調用：

• getX() 和 getY() 可以捕捉到機器人當前的坐標。
  
• getHeading() 、 getGunHeading() 和 getRadarHeading() 可以得出坦克車、炮或雷達當前的方向，該方向是以角度表示的。
  
• getBattleFieldWidth() 和 getBattleFieldHeight() 可以得到當前這一回合的戰場尺寸。

射擊命令

一旦您掌握了移動機器人以及相關的武器裝備的方法，您就該考慮射擊和控制損害的任務了。每個機器人在開始時都有一個缺省的“能量級別”，當它的能量級別減小到零的時候，我們就認為這個機器人已經被消滅了。射擊的時候，機器人最多可以用掉三個能量單位。提供給炮彈的能量越多，對目標機器人所造成的損害也就越大。 fire(double power) 和 fireBullet(double power) 用來發射指定能量（火力）的炮彈。調用的 fireBullet() 版本返回 robocode.Bullet 對象的一個引用，該引用可以用于高級機器人。

事件

每當機器人在移動或轉動時，雷達一直處于激活狀態，如果雷達檢測到有機器人在它的范圍內，就會觸發一個事件。作為機器人創建者，您有權選擇處理可能在戰斗中發生的各類事件。基本的 Robot 類中包括了所有這些事件的缺省處理程序。但是，您可以覆蓋其中任何一個“什么也不做的”缺省處理程序，然后實現您自己的定制行為。下面是一些較為常用的事件：

• ScannedRobotEvent 。通過覆蓋 onScannedRobot() 方法來處理 ScannedRobotEvent ；當雷達檢測到機器人時，就調用該方法。
  
• HitByBulletEvent 。通過覆蓋 onHitByBullet() 方法來處理 HitByBulletEvent ；當機器人被炮彈擊中時，就調用該方法。
  
• HitRobotEvent 。通過覆蓋 onHitRobot() 方法來處理 HitRobotEvent ；當您的機器人擊中另外一個機器人時，就調用該方法。
  
• HitWallEvent 。通過覆蓋 onHitWall() 方法來處理 HitWallEvent ；當您的機器人撞到墻時，就調用該方法。

我們只需要知道這些就可以創建一些相當復雜的機器人了。您可以通過戰場的幫助菜單或 Robot Editor 的幫助菜單訪問 Javadoc 中其余的 Robocode API。

現在，我們該把學到的知識付諸實踐了。

回頁首

創建機器人

要創建一個新的機器人，請啟動 Robot Editor 并選擇 File-> New-> Robot。系統將會提示您輸入機器人的名稱，這個名稱將成為 Java 類名。請您在提示符處輸入 DWStraight。接下來，系統還會提示您輸入一個獨一無二的包前綴，它將用作存放機器人（還可能有相關的 Java 文件）的包的名稱。請在該提示符處輸入 dw。

Robot Editor 就會顯示您要控制這個機器人需要編寫的 Java 代碼。清單 1 是您將會看到的代碼的一個示例：

												
														package dw;
import robocode.*;

/**
 * DWStraight - a robot by (developerWorks)
 */
public class DWStraight extends Robot
{
    ...  // <<Area 1>>
    /**
     * run: DWStraight's default behavior
     */
    public void run() {
        ... // <<Area 2>>
        while(true) {
        ... // <<Area 3>>
        }
    }
      ... // <<Area 4>>
    public void onScannedRobot(ScannedRobotEvent e) {
        fire(1);
    }
}

												
										

突出顯示的區域就是我們添加控制機器人的代碼的地方：

Area 1
我們可以在這片空白里聲明類作用域變量并設置這些變量的值。這些變量可以在機器人的 run() 方法內以及其他一些您可能創建的助手方法內使用。

Area 2
戰斗管理器調用 run() 方法激活機器人。典型情況下，run() 方法包括兩個區域（即在清單 1 中指出的 Area 2 和 Area 3），您可以在這兩塊空白里添加代碼。您在 Area 2 中加入的代碼每個機器人實例只運行一次。這部分代碼通常用于使機器人先處于一種預設狀態后再開始執行重復行為。

Area 3
這是典型的 run() 方法實現的第二部分。在此，我們將在無限 while 循環內對機器人可能執行的重復行為進行編程。

Area 4
您可以在這一區域內添加機器人在 run() 邏輯內使用的助手方法。您也可以在此添加您想要覆蓋的任何事件處理程序。例如，清單 1 里的代碼處理 ScannedRobot 事件，每當雷達檢測到機器人的時候，只是直接向其發射炮彈。

我們對第一個機器人（DWStraight）的代碼的更新如清單 2 中紅色標記所示。

												
														package dw;
import robocode.*;

public class DWStraight extends Robot
{
    public void run() {
        turnLeft(getHeading());
        while(true) {
            ahead(1000);
            turnRight(90);

        }
    }
         public void onScannedRobot(ScannedRobotEvent e) {
        fire(1);
    }
    public void onHitByBullet(HitByBulletEvent e) {
        turnLeft(180);
    }
      
}

												
										

下面我們逐區地描述這個第一個機器人將做些什么：

Area 1我們沒有在這個機器人的程序中指定任何類作用域變量。

Area 2
為了使機器人處于已知的狀態，我們通過 turnLeft(getHeading()) 使它轉到 0 度的方向。

Area 3
在這個重復性的部分，我們使用語句 ahead(1000) 讓機器人盡其所能向前移動到最遠的地方。當機器人撞到墻或其他機器人時，就會停下來。接著，我們通過 turnRight(90) 使它向右轉。在重復執行這一行為時，機器人基本上是在沿著墻按順時針方向移動。

Area 4
在此，除處理自動生成的 ScannedRobot 事件并向被發現的機器人直接射擊之外，我們還會檢測 HitByBullet 事件，并且讓機器人在被擊中的時候轉過 180 度（沿順時針方向或逆時針方向）。

回頁首

編譯以及測試機器人

在 Robot Editor 菜單上選擇 Compiler-> Compile編譯您的機器人代碼。現在我們可以嘗試第一回合的戰斗了。切換回戰場并選擇菜單上的 Battle-> New，將會出現一個類似于圖 3 中所示的對話框。

請先將我們的機器人 dw.DWStraight 添加到戰斗中，然后再添加一個對手機器人，比如 sample.SittingDuck。單擊 Finish，戰斗就開始了。不可否認，同 SittingDuck 戰斗并不怎么有趣，但是您可以目睹這個叫做 DWStraight 的機器人在缺省情況下的行為。試試 sample 文件夾里的其他機器人，看看 DWStraight 同這些機器人的戰斗情況如何。

當您準備開始研究另外一個機器人的代碼時，請先看看隨 參考資料 中的代碼分發包一起提供的 dw.DWRotater 這個機器人的代碼。在缺省情況下，這個機器人將會：

• 移動到戰場中心
• 一直轉動它的炮，直到檢測到機器人
• 每次嘗試以不同的角度在離被檢測到的機器人前方不遠的地方射擊
• 每當它被另外一個機器人擊中時，它都會迅速的來回移動

這段代碼簡單易懂，所以我們在這里就不做分析了，但是我鼓勵您試驗一下。Robocode 中的 sample 包還提供了許多其他機器人的代碼。

附加的機器人支持類

隨著您設計機器人的水平的提高，機器人的代碼主體將充分增長。對這些代碼的一種模塊化處理方法是把代碼分解成獨立的 Java 類，然后通過打包器把這些 Java 類打包成一個單獨的包（JAR 文件），并將它包括在您的機器人分發包內。Robocode 將自動在它的 robots 目錄下的包里找到 robot 類。

其他 Robot 子類

任何人都可以創建 Robot 子類并添加用于構建機器人的新功能。Robocode 提供了一個叫做 AdvancedRobot 的 Robot 子類，它允許異步 API 調用。雖然對 AdvancedRobot 類的描述超出了本文的范圍，但我鼓勵您在掌握了基本的 Robot 類的操作后，試驗一下這個高級類。

設計 Robocode 的目的 我碰見了 Robocode 的創建者 Mathew Nelson，向他請教創建 Robocode 最初的設計目的。Mat 所說的是：“編寫 Robocode 的一部分目的是為了向世界證明：象‘Java 比較慢’以及‘Java 不可以用來寫游戲’之類的論斷不再正確。我認為我證明了這一點。”

回頁首

戰斗仿真器的體系結構

通過“在后臺”對 Robocode 進行分析，我們發現復雜的仿真引擎既具高性能（為了以現實的速度生成戰斗）又具靈活性（使創建復雜的機器人邏輯不存在障礙）。特別感謝 Robocode 的創建者 Mathew Nelson 無私的提供了仿真引擎體系結構的內部信息。

利用 Java 平臺進行設計

圖 4 中所示的仿真引擎利用的是大多數現代的 Java VM 都提供的非搶占式線程技術，并結合使用了 JDK GUI 和 2D 圖形庫提供的生成功能。

請注意，所仿真的每個機器人都在它自己的 Java 線程上，它可以在任何可適用的地方利用 VM 本地線程映射機制。戰斗管理器線程是系統的控制器：它安排仿真并驅動圖形化的生成子系統。圖形化的生成子系統本身是基于 Java 2D 和 AWT 的。

松散的線程耦合

為了減少共享資源可能帶來的問題（以及有可能隨之出現的死鎖或阻塞仿真引擎），戰斗管理器線程和機器人線程之間的耦合應當非常松散。為了實現這種松散耦合，每個機器人線程都將有屬于自己的事件隊列。獲取及處理這些事件都是在每個機器人自己的線程內進行。這種基于線程的隊列有效地消除了戰斗管理器線程和機器人線程之間（或機器人線程本身之間）可能存在的任何爭用。

Robocode 內部結構

您可以把 Robocode 仿真器引擎看作是一個仿真器程序，該程序在運行時會使用一些插件（定制機器人）；這些插件可以利用已有的 API（ robocode.Robot 類的方法）。實際上，每個機器人都是一個獨立的 Java 線程，同時 run() 方法內包含了每個線程上將要執行的邏輯。

在任何時候，機器人線程都可以調用由它的父類 robocoode.Robot 類所提供的 API。典型情況下，這將通過調用 Object.wait() 阻塞機器人線程。

戰斗管理器線程

戰斗管理器線程管理機器人、炮彈及它們在戰場上的生成。仿真“時鐘”是根據戰場上生成的幀的數目來標記的。用戶可以調整真實的幀的速度。

在一個典型的回合中，戰斗管理器線程喚醒每個機器人線程，然后等待機器人完成它的一輪戰斗(即，再次調用一個阻塞 API）。等待的間隔時間通常是幾十毫秒，即使是最復雜的機器人，使用現今典型的系統速度進行策略安排和計算，也只要 1 到 2 毫秒的時間。

以下是戰斗管理器線程執行的邏輯的偽代碼：

												
														while (round is not over) do
   call the rendering subsystem to draw robots, bullets, explosions
   for  each robot do
       wake up the robot
       wait for it to make a blocking call, up to a max time interval
   end for
   clear all robot event queue
   move bullets, and generate event into robots' event queue if applicable
   move robots, and generate event into robots' event queue if applicable
   do battle housekeeping and generate event into robots' event queue
         if applicable
   delay for frame rate if necessary
end do

												
										

請注意，在 for 循環內部，戰斗管理器線程的等待時間不會超過最大的時間間隔。如果機器人線程沒有及時調用阻塞 API（典型情況下是由于一些應用程序邏輯錯誤或無限循環），那么，它將繼續進行戰斗。生成一個 SkippedTurnEvent 并將其加入機器人事件隊列中，用來通知高級機器人。

可替換的生成子系統

AWT 和 Java 2D 線程就是當前實現中的生成子系統，它從戰斗管理器中獲取命令并生成戰場。它同系統的其余部分是完全分離的。我們可以預見到，在這個生成子系統將來的修訂版中，它可以被替換掉（比如，用 3-D 生成器）。在當前的實現中，只要 Robocode 應用程序被最小化，生成就禁用了，這可以以更快的速度進行仿真。

回頁首

Robocode 的未來

通過 alphaWorks Robocode 站點上的一個討論組（請參閱 參考資料 ），Mathew Nelson 可以同 Robocode 用戶社區保持緊密的反饋聯系。許多反饋都并入了真實的代碼中。Mathew 已計劃即將要進行的一些改進有：

• 通過不同的物體和障礙來定制戰場地圖
• 基于團隊的戰斗
• 對聯賽或聯盟的集成支持
• 用戶可選擇坦克車體／炮／雷達／武器的樣式

回頁首

擋不住的 Robocode 風潮

對于一個從 2001 年 7 月 12 日出現在公眾面前的項目，Robocode 的出名簡直讓人吃驚。盡管最新的可用版本還不到 1.0（在寫這篇文章時是版本 0.98.2），但它已經是全世界的大學校園以及公司的 PC 機上頗受歡迎的娛樂活動了。Robocode 聯盟（或 roboleagues）正如雨后春筍般出現，在這些聯盟里，人們通過因特網讓自己定制的作品相互較量。大學教授們一直在挖掘 Robocode 的教育特性，并且已經把它納入了大學里的計算機科學課程。在因特網上，Robocode 用戶組、討論列表、FAQ、教程和 Webring 隨處可見。

顯然，Robocode 已經填補了大眾化的寓教于樂領域的空白 ― 它為學生們和熬夜的工程師們提供簡便、有趣、非脅迫卻富競爭力的方式，釋放他們的創造力，而且有可能實現他們征服世界的夢想。

在論壇上面常常看到初學者對線程的無可奈何，所以總結出了下面一篇文章，希望對一些正在學習使用java線程的初學者有所幫助。

首先要理解線程首先需要了解一些基本的東西，我們現在所使用的大多數操作系統都屬于多任務，分時操作系統。正是由于這種操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統呢，通俗一點與就是可以同一時間執行多個程序的操作系統，在自己的電腦上面，你是不是一邊聽歌，一邊聊天還一邊看網頁呢？但實際上，并不上cpu在同時執行這些程序，cpu只是將時間切割為時間片，然后將時間片分配給這些程序，獲得時間片的程序開始執行，不等執行完畢，下個程序又獲得時間片開始執行，這樣多個程序輪流執行一段時間，由于現在cpu的高速計算能力，給人的感覺就像是多個程序在同時執行一樣。
一般可以在同一時間內執行多個程序的操作系統都有進程的概念.一個進程就是一個執行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此可以想像創建并執行一個進程的系統開像是比較大的，所以線程出現了。在java中，程序通過流控制來執行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.（你可以將前面一句話的程序換成進程，進程是程序的一次執行過程,是系統運行程序的基本單位）

線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常只有微處理器的寄存器數據,以及一個供程序執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.

多任務是指在一個系統中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程，同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.

[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序執行或管理多個線程執行任務的能力，每個線程可以獨立于其他線程而獨立運行，當然也可以和其他線程協同運行，一個類控制著它的所有線程，可以決定哪個線程得到優先級，哪個線程可以訪問其他類的資源，哪個線程開始執行，哪個保持休眠狀態。
下面是線程的機制圖：


線程的狀態表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創建,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處于這五種狀態之一：
1.創建狀態
使用new運算符創建一個線程后,該線程僅僅是一個空對象,系統沒有分配資源,稱該線程處于創建狀態(new thread)
2.可運行狀態
使用start()方法啟動一個線程后,系統為該線程分配了除CPU外的所需資源,使該線程處于可運行狀態(Runnable)
3.運行中狀態
Java運行系統通過調度選中一個Runnable的線程,使其占有CPU并轉為運行中狀態(Running).此時,系統真正執行線程的run()方法.
4.阻塞狀態
一個正在運行的線程因某種原因不能繼續運行時,進入阻塞狀態(Blocked)
5.死亡狀態
線程結束后是死亡狀態(Dead)

同一時刻如果有多個線程處于可運行狀態,則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優先級(priority),優先級的高低反映線程的重要或緊急程度.可運行狀態的線程按優先級排隊,線程調度依據優先級基礎上的"先到先服務"原則.
線程調度管理器負責線程排隊和CPU在線程間的分配,并由線程調度算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態.

線程調度是先占式調度,即如果在當前線程執行過程中一個更高優先級的線程進入可運行狀態,則這個線程立即被調度執行.先占式調度分為:獨占式和分時方式.
獨占方式下,當前執行線程將一直執行下去,直 到執行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優先級的線程搶占
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執行完也要讓出CPU,進入可運行狀態,等待下一個時間片的調度.系統選中其他可運行狀態的線程執行
分時方式的系統使每個線程工作若干步,實現多線程同時運行

另外請注意下面的線程調度規則（如果有不理解，不急，往下看）：
①如果兩個或是兩個以上的線程都修改一個對象，那么把執行修改的方法定義為被同步的（Synchronized）,如果對象更新影響到只讀方法，那么只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態發生變化，那么它應該在對象內部等待，而不是在外部等待，它可以調用一個被同步的方法，并讓這個方法調用wait()
③每當一個方法改變某個對象的狀態的時候，它應該調用notifyAll()方法，這給等待隊列的線程提供機會來看一看執行環境是否已發生改變
④記住wait(),notify(),notifyAll()方法屬于Object類，而不是Thread類，仔細檢查看是否每次執行wait()方法都有相應的notify()或notifyAll()方法，且它們作用與相同的對象 在java中每個類都有一個主線程，要執行一個程序，那么這個類當中一定要有main方法，這個man方法也就是java class中的主線程。你可以自己創建線程，有兩種方法，一是繼承Thread類，或是實現Runnable接口。一般情況下，最好避免繼承，因為java中是單根繼承，如果你選用繼承，那么你的類就失去了彈性，當然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種，具體情況具體分析。


eg.繼承Thread

				public class MyThread_1 extends Thread
{
public void run()
{
//some code 
}
}
		

				public class MyThread_2 implements Runnable
{
public void run()
{
//some code 
}
}
		

				new MyThread_1().start()
		

				new Thread(new MyThread_2()).start()
		

				public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
new Thread(new MyThread()).start(); 
}
} 
		

				new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
		

				public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//賦予最高優先級
t1.start();
t2.start();
t3.start();
}
} 
		

				public class MyThread implements Runnable
{ 
public void run()
{ 
try
{
int sleepTime=(int)(Math.random()*100);//產生隨機數字，
Thread.currentThread().sleep(sleepTime);//讓其休眠一定時間，時間又上面sleepTime決定
//public static void sleep(long millis)throw InterruptedException （API）
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于線程在休眠可能被中斷，所以調用sleep方法的時候需要捕捉異常
{
ie.printStackTrace();
} 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}
		

				public static void main(String[] args)
{
/***************************************
ThreadGroup(String name) 
ThreadGroup(ThreadGroup parent, String name) 
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}
		

				class BlankSaving //儲蓄賬戶
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向銀行存入了 [￥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向銀行取走了 [￥"+i+"]");
if(money<0)
System.out.println("余額不足！"); 
}
public int showMoney()
{
return money;
}
} 


class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;



}
public static void oper(String name,BlankSaving bs)
{



if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{



for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
} 
}
public class BankTest 
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}



}
		

				class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{ 
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}
		

				String s1 = "abc" ;
String s2 = "abc" ;
if( s1 == s2 ) 
????System.out.println("s1,s2 refer to the same object");
else???? System.out.println("trouble");
		

				String s1 = new String("abc") ;
String s2 = new String("abc") ;
if( s1 == s2 ){ //不會執行的語句}
		

				class A{
????int i = 10;
????public static void main(String []args){
????????String str = new String("jf");
????????str += new A();
????????System.out.print(str);
????}

????public String toString(){
????????return " a.i ="+i+"\n";
????}
}
		

				String str1 ="3jf34";
????????String str2 ="3"+"jf"+"3"+"4"; 
????????if(str1 == str2) {
????????????System.out.println("str1 == str2");
????????}else {
????????????System.out.println("think again");
????????}
????????if(str2.equals(str1))
????????????System.out.println("yet str2.equals(str1)");
		

				????String x = "aaa " + "bbb ";
????if (false) {
????????x = x + "ccc ";
????}
????x +=??"ddd ";

????等價于：

????String x = "aaa bbb ";
????x = x + "ddd ";
		

abstract class和interface在Java語言中都是用來進行抽象類定義的

Interface ,給外界的接口,按照規定辦事；
Abstract??,內部繼承關系；

interface 就是一組操作的集合,它定義了一個行為集但不作任何具體的實現,這樣的話,具體的操作 都可以放在實現類中去,
??????????體現設計與實現分離的設計思想。

在面向對象的概念中，所有的對象都是通過類來描繪，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類
抽象概念在問題領域沒有對應的具體概念，所以用以表征抽象概念的抽象類是不能夠實例化的。

=====================================================================================================================
使用abstract class的方式定義Demo抽象類的方式如下：

				abstract class Demo {
abstract void method1();
abstract void method2();
…
}
		

使用interface的方式定義Demo抽象類的方式如下：

				interface Demo {
void method1();
void method2();
…
}
		

====================================================================================================================
從編程層面看abstract class和interface

abstract class在Java語言中表示的是一種繼承關系，一個類只能使用一次繼承關系
一個類卻可以實現多個interface

在abstract class的定義中，我們可以賦予方法的默認行為
在interface的定義中，方法卻不能擁有默認行為

======================================================================================================================
例如要設計一個形狀類MShape，從此類可以派生 方形、圓形、三角形等子類。我們就可以將MShape這個父類設計為abstract類。

比如，子類都有 color 屬性，因此可以把 color 這個數據成員，以及給 color 賦值的method均設計在父類中，
這樣就不用在每個子類中設計相同的代碼來處理 color 這個屬性。
而如果想計算幾何形狀的面積，由于各個幾何形狀的面積計算方式都不相同，所以把計算面積的method的處理放在父類中就不合適，
但由于每個幾何形狀都需要用到這個method，因此可以在父類中只聲明計算面積的method "area()"，而把具體的處理放在子類中定義。
即把area()設計為抽象類。

以下是程序代碼：
//abstract類 MShape??????

				abstract class MShape
{
????????protected String color;?? //數據成員
????????public void setColor(String mcolor)?? //一般方法，定義了具體的處理 
????????{
?????????? color=mcolor;
????????}
????????abstract void area();?? //抽象方法，沒有定義具體的處理
}
		

//方形類

				class RectShape extends MShape
{?????? 
????????int width,height,rectarea;????
????????public RectShape(int w,int h)
????????{??
???????????????? width=w;
???????????????? height=h;????????
????????}
????????public void area()??//計算面積
????????{??????????
??????????rectarea=width*height;
????????}
}
		

//使用

				public class myapp
{
????????public static void main(String args[])
????????{
??????????RectShape rect=new RectShape(3,6);
??????????rect.setColor("Red");
??????????rect.area();
??????????System.out.print("color="+rect.color+", area="+rect.rectarea);
????????}
}
		

由此可見，在abstract中不僅可以定義一般的方法（即可以進行具體處理的方法），還可以象interface一樣定義抽象方法。
而在interface中只能定義抽象方法。