Java程序設計實用教程 by 朱戰立 & 沈偉

學習筆記之JAVA多線程（http://www.cnblogs.com/pegasus923/p/3995855.html）

國慶休假前學習了多線程，休假花了兩天時間把整本書學完了。看書還就得一鼓作氣。

?第一章　　概述

• 1995年SUN正式發布Java，前身是Oak。
• 1998年發布帶有JDK1.2的Java 2。
• JDK（JAVA DEVELOPMENT KIT），也稱作JAVA SDK(JAVA SOFTWARE DEVELOPMENT KIT)。
• J2ME(JAVA 2 MICRO EDITION)
• J2SE(JAVA 2 STANDARD EDITION)
• J2EE(JAVA 2 ENTERPRISE EDITION)
• 簡單、面向對象和與現有高級語言形式類似。
• 魯棒性和安全性。可靠性依靠JAVA的編譯時檢查和運行時檢查兩層檢查機制實現。主要用于分布式的網絡環境。
• 結構中立。JAVA先編譯產生字節碼（不依賴于任何硬件和操作系統的中間代碼），然后用解釋的方法產生最終在具體計算機上運行的機器碼。
• 高性能。解釋性程序設計語言運行速度慢，JAVA是半解釋型，但JAVA的解釋執行能全速進行，不用檢查運行時的環境（因該環境已在編譯時保證）。自動垃圾回收線程定義成優先級很低的后臺線程，只在系統空閑時啟動執行，也保證了運行速度。
• 解釋型、多線程和動態性。只要安裝JAVA解釋器，JAVA字節碼就能在任何計算機上解釋執行。JAVA的多線程機制可提高復雜應用程序的運行速度，并且有系統提供的同步功能做安全保證。JAVA的對象綁定是動態的，類在被要求的時候才被從指定任意位置導入。
• 和C++等相比，JAVA是純面向對象的高級語言。
• 獨立于各種操作平臺。先按編譯方式翻譯到字節碼，然后把字節碼按解釋方式翻譯到具體機器的機器語言。這種半編譯、半解釋的高級語言翻譯方式，使獨立于硬件環境和操作系統平臺。
• 安全性好。
• 多線程。操作系統多任何和分時，允許同一時間運行多個程序。主要有多進程和多線程兩種方式，多線程效率更高。同步機制能保證多線程正確運行。
• 字節碼(BYTECODE)是和任何具體機器環境無關的中間代碼。
• JAVA程序文件為.JAVA，字節碼文件.CLASS。
• JAVA虛擬機（JAVA VIRTUAL MACHINE, JVM）上有JAVA解釋器。
• JAVA一次編寫，任意運行（WRITE ONCE, RUN ANYWHERE），解決了硬件環境和操作系統平臺的異構問題。
• 網絡環境下應用軟件的開發模式多是B/S（BROWSE/SERVER）模式，即應用軟件放在服務器端，客戶端通過瀏覽器來進行應用。B/S模式的應用系統特別需要異構環境的支持。
• 嵌入HTML的JAVA程序稱作APPLET程序（小程序）。
• 如果把JAVA源程序在瀏覽器上按解釋方式運行，客戶計算機的運行速度將非常慢。
• 當JAVA虛擬機采用硬件直接實現時，運行速度將大大快于目前的運行速度。
• JDK的文件夾結構：BIN，包含編譯器、解釋器等可執行文件；DEMO，程序示例；INCLUDE，頭文件，用于本地機的C語言；INCLUDE-OLD，頭文件，用于兼容支持舊接口；JRE，JAVA運行時環境的根路徑；LIB，可執行程序使用的包文件。
• set path設置了JAVA編譯運行程序的路徑。
• set classpath設置了JAVA包的路徑，最前面的“.”表示在當前工作路徑下可執行JAVA程序。
• JAVA源程序文件名必須和類名完全一樣；JAVA文件名的命名也是大小寫敏感；JAVA源程序文件名后綴必須為.JAVA。
• 編譯命令JAVAC將編譯.JAVA，若編譯正確，產生相應字節碼文件（類文件）.CLASS。
• 運行命令JAVA可運行.CLASS。
• JAVA程序主要有兩種：JAVA APPLICATION（應用程序）和JAVA APPLET（小程序）。
• JAVA APPLET是嵌入在網頁中、用瀏覽器加載后才能解釋執行的程序。

?第二章　　JAVA語言基礎

• JAVA語言的字符使用UNICODE編碼標準。
• 標識符由字母數字下劃線_和美元符$組成，必須以字母_或$開頭，字符個數有限的字符序列。字母符號大小寫敏感，區分大小寫。
• JAVA有47個固定含義的標識符，關鍵字。
• 變量必須先定義（聲明），才能賦值。
• 變量定義是指示編譯器為特定數據類型的數值保存在內存中分配適當的內存空間。
• 變量的使用范圍稱作變量的作用域。
• 常見的程序塊形式是if、while、for等后面跟隨的一對花括號。
• 整個程序運行期間保持不變的變量稱為常量。
• 定義常量用關鍵字final。
• 常量名通常全大寫字母。
• 數據類型規定一類數據的數據位長度（字符個數），取值范圍，以及對該類數據所能進行的操作。
• JAVA定義了8種基本數據類型：整型，byte/short/int/long；浮點型，float/double；邏輯型，boolean；字符型，char。
• byte 8 bits, short 16 bits, int 32 bits, long 64 bits.
• 十進制首位不能為0；八進制以0打頭；十六進制以0x或0X打頭。
• 字面值是程序中用到的顯示數據值。所有整型字面值都隱含為int型。若要表示為long型時，在后面加L或l，如12345L。
• 浮點型由整數部分和小數部分組成。兩種表示方式標準記數法和科學記數法，指數部分由e(E)后跟帶正負號的整數表示。
• float 32 bits, double 64 bits.
• 所有浮點型數的字面值隱含為double。若要表示為float，需加F或f，如123.123F。
• 邏輯型用來定義保存邏輯值的變量，也稱布爾型。
• 一個UNICODE標準下的編碼稱作一個字符。
• 字符型字面值用一對單引號括起來。
• 轉義字符：\r 回車，\\ 反斜杠，\' 單引號，\“ 雙引號。
• JAVA是強類型語言。強類型語言是指對數據類型的匹配要求十分嚴格。如果表達式的數據類型不一致，則編譯器給出類型不一致的出錯信息。
• 賦值語句的類型匹配有兩種：類型相同和類型兼容。類型兼容是指賦值號左端的數據類型比賦值號右端的數據類型長。數據類型長，是指數據類型的位數長。
• 類型不兼容時，可以重新定義賦值號，或用強制類型轉換。強制類型轉換可能丟失數據或損失數據的精度。
• JAVA在基本關鍵字、運算符、表達式、賦值語句、流程控制語句等方面，是和C/C++基本相同的。
• JAVA運算符分為四類：算術運算符、關系運算符、邏輯運算符和位運算符。
• 算術運算符分為一元和二元，操作數必須是數值類型。
• 一元運算符：+/-/++/--。一元運算符與其前后的操作數之間不允許有空格，否則編譯出錯。
• 二元運算符：+/-/×///%。取余運算符可用于整數和浮點數的情況。
• 二元運算的所得結果的數據類型與精度較高（位數更長）的那種數據類型一致。
• 關系運算符：==/！=/>/>=/</<=。
• 邏輯運算符：&&/||/!/^/&/|。
• &和|運算是把邏輯表達式全部計算完，而&&和||運算具有短路計算功能。短路計算，指系統從左至右進行邏輯表達式的計算，一旦出現計算結果已經確定的情況，則計算過程即被終止。短路計算功能可以提高程序的運算速度。在程序設計時使用&&和||運算符，而不使用&和|。
• 位運算是以二進制位為單位進行的運算，其操作數和運算結果都是整型值。
• 位運算符：&/|/～/^/>>/<</>>>。位運算相應的操作數和運算結果都是二進制整數，而邏輯運算相應的操作數和運算結果都是邏輯值。
• 右移是將一個二進制數按指定位數向右移位，移掉的被丟棄，左邊移進的部分補0（該數為正時），或者補1（該數為負時）。整數在機器內部采用補碼表示法，正數符號位為0，負數的符號位為1。
• 0填充的右移>>>：不論正負，左邊移進的部分一律補0。
• 賦值運算符還可以與二元算術運算符、邏輯運算符和位運算符組合成簡捷運算符，如 +=。
• []是數組運算符，其中數值為數組下標。
• ()用于改變表達式中運算符的優先級。
• 操作數是字符串時，+運算符用來合并兩個字符串；當一邊是字符串，一邊是數值時，機器自動將數值轉換為字符串。
• 條件運算符（?:）
• 對象運算符instanceof用來測試一個指定對象是否是指定類（或其子類）的實例。
• 點運算符（.）功能：一是引用類中成員；二是指示包的層次等級。
• 用運算符和圓括號把運算對象連接起來的、符合JAVA語言語法規則的式子稱作表達式。
• 表達式按照運算符優先級高的先運算；同一優先級的運算符，按照運算符的結合性（從左向右還是從右向左）的次序進行運算。大多數從左向右，少數（賦值、條件運算等）是從右向左。
• 表達式還可以是某個類的方法調用。
• 流程控制語句用來控制程序的執行流程：條件選擇，循環，和轉移語句。
• 基本結構：順序結構，分支結構和循環結構。
• 一個以;結束的符號串稱為語句。
• JAVA流程控制語句有：分支語句，if, switch；循環語句，for, while, do-while；轉移語句，break, continue。
• 函數或類的成員函數運行結束后需要返回原調用處，并可能需要帶回返回值的流程控制用return語句。
• if實現二路分支，switch多路分支。
• if-else中，else語句是任選的。
• JAVA規定：else總是與最近的一個if語句匹配。
• switch, case, default是關鍵字，default語句是可選的。
• switch表達式和case常量值的類型可以是byte,short,int,long和char，但不能為boolean，并且要求兩者的數據類型必須一致。
• switch語句中的break語句結束switch語句的執行。
• for語句中的循環初始化，循環條件判斷和循環變量修改都可以任選，即for (;;)。
• 循環過程永不結束，為死循環。
• do-while至少執行一次循環體，while可以一次也不執行。
• break通常和switch或循環語句配合使用；continue通常和循環語句配合使用。
• continue語句僅跳過當前層中循環體的剩余語句。
• 若函數為void類型，則return語句后沒有返回值；若為非void，則return語句后需要有返回值，且返回值的累心個必須和函數的類型一致。
• 當return語句不帶返回值，并且位于函數的最后時，它可以省略。
• 單行注釋以//開頭，至行尾；多行注釋以/*開頭，以*/結束；文件注釋用來自動生成一個HTML文檔，為程序自動提供網絡環境下的文檔說明，以/**開頭，以*/結束。
• 數組是連續內存單元中一組名字和數據類型相同的數據元素的有限集合。數組中每個數據元素稱作數組元素。JAVA還可以構造不規則數組。
• JAVA使用一維數組分三步：定義一堆數組變量、為數組分配內存單元和使用數組元素。
• 數組定義后，系統將給數組標識符分配一個內存單元，用于指示數組在內存中的實際存放位置。由于數組變量定義時，數組元素本身在內存中的實際存放位置還沒給出，所以此時該數組名的值為空NULL。
• new運算符：向系統申請指定數據類型所需的內存單元空間。new運算符返回所申請內存單元的首地址。
• JAVA規定，在數組分配內存單元后，系統將自動給每個數組元素賦初值，數值型為0，邏輯型為false，類類型為null。
• 數組下標由0開始。
• 數組名是指向內存中存放數組元素的一片連續內存單元的首地址。
• 數組名的類型是引用類型。引用類型是指該類型的標識符所表示的是一片內存連續地址的首地址。字符串名和數組名，所有對象名都是引用類型。
• 數組的定義和為數組分配內存空間兩步可以結合起來。數組元素的初始化賦值也可以結合一起。
• JAVA提供了length成員變量返回數組元素的個數。
• 如果一維數組的每個數組元素都是一個一維數組，則構成二維數組。若二維數組中的每個一維數組定義為不同的元素個數，就構成不規則的二維數組。
• 字符串是N(N>=0)個字符組成的序列。JAVA中字符串用雙引號括起來，字符個數稱作字符串長度。
• JAVA字符串變量用String來定義。String是JAVA API中定義的一個類。
• 一對雙引號括起來的任何字符序列都是一個字符串常量。
• 把一片連續內存單元的首地址賦給字符串變量名，是讓字符串變量指向存放字符串的內存單元的首地址。
• JAVA提供了特殊的字符串運算符+，把兩個字符串連接起來。
• System.out.print()和Sytem.out.println()要求的參數是字符串或字符串表達式。

第三章　　類和對象

• 類是對具有相同屬性和方法的一組相似對象的抽象。對象是類的實例。包是JAVA組織和管理類的一種方法。
• 類的封裝性、多態性和繼承性是OOP的重要特點。
• 類的設計分為類聲明和類主體設計兩部分。
• 接口名多于一個時用逗號分隔開。
• 類聲明的修飾符分為訪問控制符和類型說明符兩部分。一起使用時，訪問控制符在前，類型說明符在后。
• 訪問控制符為public，被定義為公共類，能被任何類訪問。包中的類能互相訪問，不在一個包中的類不能直接訪問，必須用import導入到該包中。被導入的類必須是public。
• 沒有public時，即是默認類（缺省類）。默認類表示該類只能被同一個包中的類訪問，不能被其他包的類訪問。JAVA文件中可以有很多類，但最多只能有一個公共類，其他為默認類。
• 類說明符為abstract時，為抽象類。抽象類不能用來定義對象，通常被設計成一些具有類似成員變量和方法的子類的父類。
• 類說明符為final時，為最終類，不能用來再派生子類。
• 由于JAVA中所有方法必定屬于某個類，即方法一定是成員方法，所以成員方法簡稱方法。
• 聲明成員變量的修飾符有private, public和protected。private成員變量只能被該類本身訪問。不加任何修飾符，定義為默認修飾符，該成員變量只能被該類本身和同一個包的類訪問。protected除可以被該類本身和同一個包的類訪問外，還可以被它的子類（包括同一個包中的子類和不同包中的子類）訪問。public可以被所有類訪問。
• static指明是類成員變量，final指明該成員變量是常量，transient為臨時變量，很少使用。
• 聲明成員方法的修飾符有private, public和protected。static指明該方法是一個類方法。
• 方法聲明中必須給出方法名和方法的返回值類型，如果沒有返回值，用關鍵字void標記。方法名后的()是必須的，即使參數列表為空，也要加上。
• 方法體是方法的具體實現。
• 定義在類中的都是成員變量，定義在方法內的都是變量，還有定義在方法參數中的虛參變量。成員變量和變量的類型既可以是基本數據類型，也可以是已定義的類。
• 專門用來進行對象初始化的方法稱為構造方法（構造函數）。一個類中至少要有一個構造方法。
• 構造方法的名字必須與類名完全相同，沒有返回值，連表示空類型void的返回值都沒有。一般應定義為public。
• 創建對象時，將調用類中的構造方法為對象的成員變量進行初始化賦值。
• 一個類對應一個.CLASS文件，一個程序文件中可以有一個或多個類，但只允許一個類被定義成public。類中可以沒有main方法。但要運行的類必須有main方法。程序就是從main方法開始執行。
• 對象和數組一樣也是引用類型，即對象定義后，系統將給對象標識符分配一個內存單元，用于存放實際對象在內存中的存放位置。
• new運算符申請對象所需的內存空間，返回所申請的內存空間的首地址。賦值語句把new運算符分配的連續地址的首地址賦給對象名。
• 程序設計時最經常使用的方法，是在定義對象的同時為對象分配內存空間和進行初始化賦值。
• 對象可以像變量一樣賦值。不同的是，對象賦值不是把取值賦給另一個對象，而是讓另一個對象名存儲的對象的首地址和這個對象名存儲的對象的首地址相同，即對象的賦值是對象的首地址的賦值。
• 對象也可以像變量一樣，作為方法的參數使用。不同的是，變量作為實參時，系統把實參的數值復制給虛參；對象作為實參時，系統把實參對象名（該對象必須已創建）指示的對象的首地址賦給虛參對象名。
• 變量的內存空間是系統在變量定義時自動分配的；當變量超出作用范圍時，系統將自動回收該變量的內存空間。
• 對象的內存空間是用new創建的。對象也有作用范圍，超出作用范圍的對象（不再使用的對象）為垃圾對象。JAVA中，收集和釋放內存由自動垃圾回收線程負責。自動垃圾回收線程在系統空閑時自動運行，這個線程監視用戶程序中所以對象的有效作用范圍；當某個對象超出其作用范圍時，該線程就對這樣的對象做上垃圾對象標識，并在適當的時候一次性回收這些垃圾對象。
• 類有實例成員變量與類成員變量。類成員變量也稱作靜態成員變量。
• 類定義中沒用關鍵字static的成員變量就是實例成員變量，不同對象的實例成員變量的值不相同。
• 用static的成員變量稱為類成員變量。一個類的所以對象共享該類的類成員變量，類成員變量可以用來保存和類相關的信息，或用來在一個類的對象間交流信息。
• 類有實例方法與類方法。類方法稱作靜態方法。
• 沒用static的方法就是實例方法。它只能通過對象來調用。實例方法可以訪問類成員變量和類變量。
• 用static的方法是類方法。類方法通過類名來調用，也可以用對象，但類名調用類方法程序的可讀性更好。類方法只能訪問類變量，不能訪問實例變量。類防范主要用來處理和整個類相關的數據。
• 類的各種方法（包括構造方法）都允許重寫（重載）。方法重寫overloading，指一個方法名定義多個方法實現。不同的方法，其參數類型或參數個數要有所不同。這就是C++提到的函數簽名。
• 方法重寫必須要么參數個數不同，要么參數類型不同，僅返回值類型的不同則是不允許的。
• OOP一個特點是公共類資源可以重用。
• 包package是JAVA提供的文件（公共類）的組織方式。一個包對應一個文件夾，一個包可以有很多類文件。包中還可以有子包，稱為包等級。
• JAVA可以把類文件存放在可以有包等級的不同的包中。
• 同一個包中的文件名必須唯一，不同包中的文件名可以相同。
• package指出該語句所在文件所有的類屬于哪個包。
• 如果一個JAVA文件中有package語句，則必須寫在源文件的第一行。
• 當多個JAVA源文件中都有package語句，且包名相同時，說明這些類同屬一個包。
• 包中存放的是編譯后的類文件.CLASS。通過import，可以導入某個包中的某個類，也可以導入某個包中的全部類，但不包含其子包。
• Windows文件用\表示一條路徑下的子路徑，JAVA用.表示一個包的子包。
• JDK規定：在一個樹形結構的包中，上層包可以導入下層包，而下層包不可以導入上層包。下層包的類要使用上層包的類時，要在類前面加上包名。
• 圖形用戶界面設計，需要導入系統包java.awt中的所有類；事件處理，需要導入事件處理包java.awt.event中的所有類。
• 一個類被嵌套定義在另一個類中，稱為內部類INNER CLASSES或內隱類。包含內部類的類稱為外部類。
• 當一個類只在某個類中使用，并且不允許除外部類外的其他類訪問時，可考慮設計成內部類。
• 在外部類中，一般通過一個內部類的對象來訪問內部類的成員變量或方法；在內部類中，可以直接訪問外部類的所有成員變量和方法。
• 當外部類引用內部類時，必須給出完整的名稱，且內部類的類名不能與外部類的類名相同。
• 內部類主要用來實現接口。
• JAVA是按類劃分程序模塊的，很好的實現了類的封裝性。
• OOP中，保證模塊正確性的基本方法是類的封裝性。類的封裝性是指類把成員變量和方法封裝為一個整體，這就劃分了模塊的界限。
• 保證模塊正確性的措施是由信息的隱藏性實現的。允許其他包程序訪問修改的成員變量/方法定義為public，只允許同一包中的其他類以及該類的子類訪問修改的成員變量/方法定義為protected，不允許其他類（內部類除外）訪問修改的成員變量/方法定義為private。
• 和其他OOP語言C++相比，JAVA增加了包的概念。這樣同一包中類之間的信息傳遞就比較方便。

1 package classAndObject; 2 3 public class MyMatrix 4 { 5 private int[][] table; 6 private int height; 7 private int width; 8 9 private void init(int m, int n) 10 { 11 table = new int[m][n]; 12 13 for (int i = 0; i < m; i ++) 14 for (int j = 0; j < n; j ++) 15 { 16 table[i][j] = (int)(Math.random() * 100); 17 } 18 } 19 20 public MyMatrix(int n) 21 { 22 height = n; 23 width = n; 24 this.init(height, width); 25 } 26 27 public MyMatrix(int m, int n) 28 { 29 height = m; 30 width = n; 31 this.init(height, width); 32 } 33 34 public int getHeight() 35 { 36 return height; 37 } 38 39 public int getWidth() 40 { 41 return width; 42 } 43 44 public int[][] getTable() 45 { 46 return table; 47 } 48 49 public MyMatrix add(MyMatrix b) 50 { 51 if (this.getHeight() != b.getHeight() && this.getWidth() != b.getWidth()) 52 { 53 System.out.println("the two matrix don't match"); 54 return null; 55 } 56 57 MyMatrix result = new MyMatrix(b.getHeight(), b.getWidth()); 58 for (int i = 0; i < b.getHeight(); i ++) 59 for (int j = 0; j < b.getWidth(); j ++) 60 { 61 result.table[i][j] = this.table[i][j] + b.table[i][j]; 62 } 63 64 return result; 65 } 66 67 public MyMatrix subtract(MyMatrix b) 68 { 69 if (this.getHeight() != b.getHeight() && this.getWidth() != b.getWidth()) 70 { 71 System.out.println("the two matrix don't match"); 72 return null; 73 } 74 75 MyMatrix result = new MyMatrix(b.getHeight(), b.getWidth()); 76 for (int i = 0; i < b.getHeight(); i ++) 77 for (int j = 0; j < b.getWidth(); j ++) 78 { 79 result.table[i][j] = this.table[i][j] - b.table[i][j]; 80 } 81 82 return result; 83 } 84 } 1 package classAndObject; 2 3 public class TestMyMatrix 4 { 5 public static void main(String[] args) 6 { 7 MyMatrix mm1 = new MyMatrix(4, 4); 8 MyMatrix mm2 = new MyMatrix(4, 4); 9 MyMatrix mm3 = new MyMatrix(4, 5); 10 MyMatrix mm4 = new MyMatrix(4, 5); 11 12 MyMatrix add_result = mm1.add(mm2); 13 int [][] add_table = add_result.getTable(); 14 MyMatrix subtract_result = mm3.subtract(mm4); 15 int [][] subtract_table = subtract_result.getTable(); 16 17 System.out.println("two matrix add result: "); 18 for (int i = 0; i < add_result.getHeight(); i ++) 19 { 20 for (int j = 0; j < add_result.getWidth(); j ++) 21 { 22 System.out.println(add_table[i][j] + " "); 23 } 24 System.out.println(); 25 } 26 27 System.out.println("two matrix subtract result: "); 28 for (int i = 0; i < subtract_result.getHeight(); i ++) 29 { 30 for (int j = 0; j < subtract_result.getWidth(); j ++) 31 { 32 System.out.println(subtract_table[i][j] + " "); 33 } 34 System.out.println(); 35 } 36 } 37 }

?第四章　　類與繼承

• 繼承就是一個新類擁有全部被繼承類的成員變量和方法，它使得大型應用程序的維護和設計變得更加簡單。
• OOP的繼承機制提供了一種重復利用原有程序模塊資源的途徑。通過新類對原有類的繼承，既可以擴充舊的程序模塊功能以適應新用戶需求，也可以滿足新的應用系統的功能要求。
• 由繼承而得到的新類為子類，被繼承的類為父類超類。子類直接的上層父類為直接父類，簡稱父類。一個子類只能有一個直接父類。
• JAVA所有類都是由OBJECT類繼承派生而來。
• 繼承有兩種：多繼承和單繼承。JAVA只支持單繼承，但接口使JAVA實際上實現了多繼承。
• JAVA所有類構成一顆類的層次樹結構。
• 定義類有兩種：不指明父類和顯示的指明父類。若定義時不指明父類，則其父類是OBJECT類。顯示指明父類，用extends。
• 子類繼承原則：能繼承public和protected的成員變量方法，不能繼承private和默認的成員變量方法。若子類聲明一個與父類同名的成員變量方法，則不能繼承，稱子類的成員變量隱藏了父類的同名成員變量，子類方法重寫了父類的同名方法。子類不能繼承父類的構造方法。
• JAVA中，每個對象都有對自身引用的訪問權，為this引用。
• super可以引用被子類隱藏的父類的成員變量方法，為super引用。經常用在子類的構造方法中。
• 子類隱藏父類的成員變量，不提倡，很少見；父類的某個方法不適合子類時，子類可以重定義它，為子類對父類方法的覆蓋overriding，這是OOP常用的設計方法。
• 方法的重寫overloading和方法的覆蓋overriding是不同的概念，實現的功能也不同。
• 子類覆蓋父類方法時，參數個數和參數類型必須相同。
• 子類對父類方法繼承有：完全繼承、完全覆蓋和修改繼承。
• JAVA以及所有OOP語言中，對象訪問方法的匹配原則是：從對象定義的類開始，逐層向上匹配尋找對象要訪問的方法。
• 繼承一方面可以大大簡化程序設計的代碼，另一方面使得大型軟件的功能修改和功能擴充較傳統的軟件設計方法容易許多。
• 方法的多態polymorphism指若以父類定義對象，并動態綁定對象，則該對象的方法隨綁定對象不同而不同。
• 對象名和實際對象的這種聯系稱作對象的綁定binding。
• 對象的動態綁定，指定一位類樹上層的對象名，可以綁定為所定義層類以及下層類的對象。對象的動態綁定和類的繼承相結合使對象的方法有多態性。
• 方法的多態性支持Vector類的copyInto()方法用Object類參數(Object []anArrary)定義一次，就可以適合于所有類的對象。
• 構造方法不能被聲明為抽象的。
• 不能有abstract static方法。
• 任何包含抽象方法的類必須被聲明為抽象類。抽象類不能直接用來定義對象。抽象類主要用于定義為若干個功能類同的類的父類。
• 抽象類一定是某個類或某些類的父類。若干個抽象類的子類要實現一些同名的方法。
• 用final指明不能被子類覆蓋的方法，為最終方法。
• 最終類可以保證一些關鍵類的所有方法，不會再以后的程序維護中，由于不經意的定義子類而被修改；最終方法可以保證一些類的關鍵方法，不會在以后的程序維護中，由于不經意的定義子類和覆蓋子類的方法而被修改。
• abstract和final不能合用。習慣上，public放在abstract/final的前面。
• 單繼承有結構簡單，層次清楚，易于管理，安全可靠的特點。多繼承則功能強大。
• 接口和抽象類非常相似，都是只定義了類中的方法，沒有給出方法的實現。
• 接口定義修飾符為缺省時，只能被同一包中的方法訪問；public時，接口被任何類的方法訪問。
• 若接口定義為默認型訪問權限，則接口中的成員變量全部隱含為final static型。意味著它們不能被實現接口方法的類改變，并且為默認訪問權限。
• 接口中定義的所有成員變量必須設置初值。
• 接口定義為public時，接口中的所有方法和成員變量全部隱含為public型。
• 保存接口的文件名必須與接口名相同。一個文件可以包含若干個接口，但最多只能有一個public，其他必須為默認。
• 為了實現接口，類必須實現定義在接口中的所有方法。若要實現多個接口，則用逗號分隔開接口名。
• JAVA API中定義了許多接口。

1 package classAndInherit; 2 3 class Shape 4 { 5 public void draw() 6 { 7 System.out.println("Draw a Shape"); 8 } 9 } 10 11 class Circle extends Shape 12 { 13 public void draw() 14 { 15 System.out.println("draw a Circle"); 16 } 17 } 18 19 class Ellipse extends Shape 20 { 21 public void draw() 22 { 23 System.out.println("draw a Ellipse"); 24 } 25 } 26 27 public class FInherit 28 { 29 public static void main(String args[]) 30 { 31 Shape s = new Shape(); 32 Shape c = new Circle(); 33 Shape e = new Ellipse(); 34 35 s.draw(); 36 c.draw(); 37 e.draw(); 38 } 39 } 1 package classAndInherit; 2 3 public class MyInter implements PrintMessage 4 { 5 private String[] v; 6 private int i; 7 8 public MyInter() 9 { 10 v = new String[3]; 11 i = 0; 12 this.putMessage("Hello world!"); 13 this.putMessage("Hello China!"); 14 this.putMessage("Hello XSYU!"); 15 } 16 17 public void putMessage(String str) 18 { 19 v[i ++] = str; 20 } 21 22 @Override 23 public void printAllMessage() 24 { 25 for (int k = 0; k < v.length; k ++) 26 { 27 System.out.println(v[k]); 28 } 29 } 30 31 @Override 32 public void printLastMessage() 33 { 34 System.out.println(v[v.length - 1]); 35 } 36 37 @Override 38 public void printFirstMessage() 39 { 40 System.out.println(v[0]); 41 } 42 43 public static void main(String[] args) 44 { 45 MyInter mi = new MyInter(); 46 System.out.println("print all messages"); 47 mi.printAllMessage(); 48 System.out.println("print the first messages"); 49 mi.printFirstMessage(); 50 System.out.println("print the last messages"); 51 mi.printLastMessage(); 52 } 53 }

?第五章　　JAVA API基礎

• JAVA語言的內核非常小，僅包含基本數據類型和語句，強大功能主要體現在JAVA完備豐富、功能強大的JAVA API上。
• JAVA API(JAVA APPLICATION PROGRAMMING INTERFACE, JAVA應用程序接口)，是JAVA提供的組織成包結構的許多類和接口的集合。
• JAVA API包含在JDK中。
• JAVA API語言包java.lang，包括Object類、Class類、Runtime類、Float類、String類和Math類；實用包java.util包括Arrays類、Vector類、Data類和Enumeration接口。
• java.lang包是使用最頻繁的包。為了簡化編程，系統固定的默認導入java.lang包，所以使用它時不用import。
• Object類是JAVA總所有類的根，在Object類中定義的成員變量和方法，在其他類中都可以使用。
• 當兩個值比較、對象或變量與值比較、兩個變量比較時，使用==；當兩個對象比較時，使用Object.equal()方法。
• System類提供了許多獲取或重新設置系統資源的靜態方法。
• System類中定義了三個和輸入輸出流有關的靜態成員變量in, out和err。

1 package javaAPI; 2 3 public class SystemTest 4 { 5 public static void main(String[] args) 6 { 7 System.out.println("java.version: " + System.getProperty("java.version")); 8 9 System.out.println("java.vm.version: " + System.getProperty("java.vm.version")); 10 11 System.out.println("java.class.path: " + System.getProperty("java.class.path")); 12 13 System.out.println("os.version: " + System.getProperty("os.version")); 14 15 System.out.println("user.name: " + System.getProperty("user.name")); 16 17 System.out.println("user.dir: " + System.getProperty("user.dir")); 18 19 System.out.println("user.home: " + System.getProperty("user.home")); 20 } 21 22 }

• Class類的實例代表一個正在運行的JAVA應用程序的類或接口。JAVA的基本數據類型，數組和關鍵字void都是由Class對象來表達。
• Class類沒有公共的構造方法，Class對象由Java虛擬機自動構造。
• Class類的forName()方法可用于安裝驅動程序。
• 每個JAVA應用程序都有一個Runtime類的實例，從而允許應用程序與其運行的環境進行交互。可利用Runtime類直接訪問運行時環境資源。

1 package javaAPI; 2 3 public class RuntimeTest 4 { 5 public static void main(String[] args) 6 { 7 Runtime rtime = Runtime.getRuntime(); 8 long totalMemory = rtime.totalMemory() / 1024; 9 long freeMemory = rtime.freeMemory() / 1024; 10 11 System.out.println("totalMemory: " + totalMemory + "KB"); 12 System.out.println("freeMemory: " + freeMemory + "KB"); 13 } 14 }

• 語言包中提供了8個數據類型包裝類的類，把JAVA語言的8個基本數據類型（byte/short/int/long/float/double/char/boolean）包裝成相應的類：Byte, Short, Integer, Long, Float, Double, Character, Boolean。
• Math類包含了一組基本的數學運算的方法和常數。Math類中所有方法都定義為靜態的。還把E和PI定義為類的靜態成員變量。
• Math類是最終類final，所有不能從Math類中派生其他的新類。
• random()方法非常有用。把random()的返回值乘上一個整數，可以得到任意區間的double類型的隨機數；若轉換成int類型，可以得到任意區間的int類型的隨機數。
• java.util包主要包含集合框架、事件模型、日期和時間機制、國際化等的類和接口。
• Arrays類中包含有數組操作的一些常用方法，如排序和查找。
• 在使用binarySearch()方法時，要求數組a中的元素已經有序排列，否則返回值未定義。
• Vector類稱作向量類，實現了動態的數組，用于元素數量變化的對象數組。Vector類也用從0開始的下標，但和數組不同的是，當Vector對象創建后，數組的元素個數會隨著Vector對象元素個數的增大和縮小變化。
• Date類提供了獲取當前精確到毫秒時間的方法，并提供許多方法截取當前時間的年月日等數值。
• Calendar類定義了許多如YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DAY_OF_WEEK等成員變量，get()方法可以獲取這些成員變量的值。

1 package javaAPI; 2 3 import java.util.*; 4 5 public class MyDate 6 { 7 public static void main(String[] args) 8 { 9 Date date = new Date(); 10 11 System.out.println(date); 12 13 Calendar now = Calendar.getInstance(); 14 int year = now.get(Calendar.YEAR); 15 int month = now.get(Calendar.MONTH) + 1; 16 int day = now.get(Calendar.DATE); 17 18 System.out.println(year + "-" + month + "-" + day); 19 20 int hour = now.get(Calendar.HOUR); 21 int minute = now.get(Calendar.MINUTE); 22 int second = now.get(Calendar.SECOND); 23 24 System.out.println(hour + ":" + minute + ":" + second); 25 26 int week = now.get(Calendar.DAY_OF_WEEK); 27 String str = "日一二三四五六"; 28 int i = week - 1; 29 30 System.out.println("星期" + str.substring(i, i + 1)); 31 } 32 }

• Enumeration接口主要用于集合類對象的序列化。所謂對象是序列化，就是說可以依次取出該對象中的元素。
• 任何一個類，只要實現了Enumeration接口，其對象就是序列化的。

1 package javaAPI; 2 3 import java.util.*; 4 5 public class Exam5_7 6 { 7 public static void main(String[] args) 8 { 9 final int SIZE = 10; 10 int i; 11 int[] a = new int[SIZE]; 12 13 for (i = 0; i < a.length; i ++) 14 { 15 a[i] = (int)(Math.random() * 100); 16 } 17 18 System.out.println("Before sort: "); 19 for (i = 0; i < a.length; i ++) 20 { 21 System.out.println(a[i] + " "); 22 } 23 24 Arrays.sort(a); 25 26 System.out.println("\nAfter sort: "); 27 for (i = 0; i < a.length; i ++) 28 { 29 System.out.println(a[i] + " "); 30 } 31 } 32 } 1 package javaAPI; 2 3 import java.util.*; 4 5 public class Josephus 6 { 7 public static void main(String[] args) 8 { 9 int n = 5, s = 0, d = 2; 10 Vector v = new Vector(n); 11 12 for (int i = 0; i < n; i ++) 13 v.add(new Integer(i + 1)); 14 15 Enumeration e = v.elements(); 16 while (e.hasMoreElements()) 17 System.out.println(e.nextElement()); 18 19 int current = s - 1; 20 while (v.size() > 1) 21 { 22 System.out.println("Vector: "); 23 for (int i = 0; i < v.size(); i ++) 24 System.out.println(((Integer)v.get(i)).intValue() + " "); 25 26 int j = 0; 27 while (j < d) 28 { 29 current = (current + 1) % v.size(); 30 j ++; 31 } 32 33 System.out.println("\tcurrent = " + current + " "); 34 v.remove(current); 35 } 36 37 System.out.println("The survivor is " + ((Integer)v.get(0)).intValue()); 38 } 39 }

?第六章　　圖形用戶界面

• 圖形用戶界面是計算機程序和用戶交流的圖形接口。
• 圖形用戶界面是由各種不同的組件按照一定的布局模式排列組成的。GUI中的組件一般包括菜單、按鈕、標簽、文本編輯行等。同時與這些組件配合工作的還有一些相關的事件。
• JAVA中，GUI所用到的類和接口都是有AWT ABSTRACT WINDOW TOOLKIT提供。AWT是JAVA API的一部分。
• java.swing包可以根據換進過來調整GUI的外觀和感覺，使得一個程序可以使用各種不同的環境。
• Component類是一個抽象類，是AWT中所有圖形組件類的父類。
• add方法可用于在任何組件類對象中添加任何組件類對象。
• Container類主要用來防止其他組件，所以稱作容器。它繼承自Component類。容器類的派生子類有：框架Frame、面板Panel、窗口Window、對話框Dialog等。
• Panel類是一個放置其他圖形組件（包括其他Panel）的容器。
• Frame類是Window的子類，主要用來放置其他組件。Frame類提供了設置標題、改變窗口大小等方法。
• Frame類對象是一個可在Window中獨立運行的窗口，而Panel類對象不能單獨運行，只能放在容器中（可以放在Frame中，也可以嵌入另一個Panel中）。
• Component類的子類除Container類外，還有Label標簽類、Button按鈕類、TextField文本輸入行類、TextArea多行文本輸入區類、Checkbox復選框類、List列表類、Choice下拉列表類等。任何一個容器類對象本身也可以放置在任何一個容器類對象中。
• Label類是用來顯示文本text的類。
• TextField類用來創建允許用戶編輯的單行文本組件。TextField可以獲得焦點，而Lable不能。所以TextField可編輯，而Label不可編輯。TextField一般用作程序的輸入。
• TextArea類用來創建允許用戶編輯的多行文本輸入組件，組件中的字符串可設定為可編輯的或只讀的。TextArea類還提供水平或垂直的滾動條。
• FlowLayout布局管理器的功能是：在此框架中加入的組件將自上而下、自左而右安排放置。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestFrame extends Frame 6 { 7 public static void main(String[] args) 8 { 9 TestFrame f = new TestFrame(); 10 f.setTitle("My First Frame"); 11 f.setSize(260, 160); 12 f.setLayout(new FlowLayout()); 13 f.setLocation(0, 0); 14 f.setResizable(false); 15 16 Label lb1 = new Label(); 17 lb1.setAlignment(Label.LEFT); 18 lb1.setText("My First Label"); 19 f.add(lb1); 20 21 Button b1 = new Button("My First Button"); 22 f.add(b1); 23 24 TextField t = new TextField(); 25 t.setText("My First TextField"); 26 f.add(t); 27 28 TextArea t1 = new TextArea("My First TextArea", 3, 20); 29 t1.setEditable(false); 30 f.add(t1); 31 f.setVisible(true); 32 } 33 }

• Checkbox類用來創建復選框組件。將幾個Checkbox對象組成一組需用到CheckboxGroup類。
• 框架中組件的位置由setBounds方法來確定（不使用任何布局管理器）。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestCheckbox extends Frame 6 { 7 public static void main(String[] args) 8 { 9 TestCheckbox f = new TestCheckbox(); 10 f.setTitle("Test Checkbox"); 11 f.setSize(300, 200); 12 f.setLayout(null); 13 14 Checkbox checkbox1 = new Checkbox("Computer", true); 15 Checkbox checkbox2 = new Checkbox("Finance", true); 16 Checkbox checkbox3 = new Checkbox("Management", false); 17 18 checkbox1.setBounds(10, 30, 60, 20); 19 checkbox2.setBounds(10, 50, 60, 20); 20 checkbox3.setBounds(10, 70, 60, 20); 21 f.add(checkbox1); 22 f.add(checkbox2); 23 f.add(checkbox3); 24 25 CheckboxGroup zct = new CheckboxGroup(); 26 Checkbox c1 = new Checkbox("Maths", zct, false); 27 Checkbox c2 = new Checkbox("English", zct, true); 28 Checkbox c3 = new Checkbox("Arts", zct, false); 29 Checkbox c4 = new Checkbox("Physics", zct, false); 30 c4.setCheckboxGroup(zct); 31 c1.setBounds(150, 30, 60, 20); 32 c2.setBounds(150, 50, 60, 20); 33 c3.setBounds(150, 70, 60, 20); 34 c4.setBounds(150, 90, 60, 20); 35 f.add(c1); 36 f.add(c2); 37 f.add(c3); 38 f.add(c4); 39 f.setVisible(true); 40 } 41 }

• List組件給用戶提供了一個滾動的文本項清單，用戶可以選中其中一項或多項文本。
• Choice是一個下拉式的數據選項，當前的選項會顯示在選中列表框中。
• 列表只能顯示當前選擇的項目，而下拉列表可以顯示多個項目。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestChoiceList extends Frame 6 { 7 public static void main(String[] args) 8 { 9 TestChoiceList f = new TestChoiceList(); 10 f.setTitle("Test ChoiceList"); 11 f.setSize(300, 200); 12 f.setLayout(new FlowLayout()); 13 14 List list1 = new List(); 15 list1.setMultipleMode(true); 16 list1.add("Liberty"); 17 list1.add("Maths"); 18 list1.add("Arts"); 19 list1.add("Physics"); 20 list1.add("KongFu"); 21 list1.select(2); 22 list1.select(4); 23 f.add(list1); 24 25 Choice choice1 = new Choice(); 26 choice1.add("University"); 27 choice1.add("Middle School"); 28 choice1.add("Primary School"); 29 choice1.add("Kindergarden"); 30 choice1.select(2); 31 f.add(choice1); 32 f.setVisible(true); 33 } 34 }

• MenuComponent類直接繼承自Object的菜單組件的基本類，它及其子類是專門用來創建菜單類組件。
• MenuBar是放置菜單的容器?？梢酝ㄟ^Frame類的setMenuBar()方法把MenuBar對象加入一個框架中。
• Menu是菜單欄上放置的菜單。每個菜單由一些菜單項組成。
• 所以菜單中的菜單項都是MenuItem類或者它的子類的對象。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestMenu extends Frame 6 { 7 public TestMenu() {} 8 9 public static void main(String[] args) 10 { 11 TestMenu frame1 = new TestMenu(); 12 frame1.setTitle("My Menu"); 13 frame1.setSize(200, 120); 14 15 MenuBar menubar1 = new MenuBar(); 16 Menu menu1 = new Menu("School"); 17 Menu menu2 = new Menu("Childcare"); 18 MenuItem menuitem1 = new MenuItem("University"); 19 MenuItem menuitem2 = new MenuItem("Middle School"); 20 MenuItem menuitem3 = new MenuItem("Primary School"); 21 MenuItem menuitem4 = new MenuItem("Kindergarden"); 22 MenuItem menuitem5 = new MenuItem("Childcare"); 23 menubar1.add(menu1); 24 menubar1.add(menu2); 25 menu1.add(menuitem1); 26 menu1.add(menuitem2); 27 menu1.addSeparator(); 28 menu1.add(menuitem3); 29 menu2.add(menuitem4); 30 menu2.add(menuitem5); 31 frame1.setMenuBar(menubar1); 32 frame1.setVisible(true); 33 } 34 }

• 一般在這幾種情況下系統會調用paint()方法繪制圖形：當一個組件第一次顯示時；當容器容器重新調整大小時；當容器從非作用窗口變為作用窗口時。
• 當程序運行在較慢的平臺上或計算機較忙時，應該考慮指定在多長時間內必須執行repaint()方法，否則就放棄。
• AWT調用update()方法來響應對repaint()方法的調用。調用update()或paint()之前，圖形的外觀將不會發生改變。update()更新圖形的步驟：先通過填充組件的背景色來清除該圖形，再設置圖形的顏色為該圖形的前景色，最后調用paint()方法完整的重新繪制該圖形。
• Color類用來設置文本或圖形的顏色。
• JAVA中顏色定義有兩種方法：Color類有很多表示顏色的常量；用RGB值設置，每種顏色的色值范圍在0～255之間，可以靈活的定義非標準色。
• Font類用來定義文字的字體、風格和大小等特性。
• Graphics類用來繪制各種圖形和字符串。雖然Graphics類提供的方法是抽象方法，但編程時可以直接使用，因為系統內部已經實現了這些抽象方法。
• 當沒有設置顏色時，組件會使用黑色（默認色）。
• main()方法中不需要調用paint()方法，但程序設計者需要重定義paint()方法來告訴系統需要繪制的圖形。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestGraphics extends Frame 6 { 7 public void paint(Graphics g) 8 { 9 int x, y, i = 0; 10 Font font = new Font("Serif", Font.ITALIC|Font.BOLD, 40); 11 12 g.setFont(font); 13 g.drawOval(60, 50, 80, 80); 14 g.setColor(Color.red); 15 g.fillOval(150, 50, 80, 80); 16 g.setColor(Color.pink); 17 g.drawOval(240, 50, 80, 80); 18 g.setColor(Color.green); 19 g.drawString("I love Java", 80, 260); 20 g.setColor(Color.blue); 21 for (i = 0; i < 20; i ++) 22 { 23 x = (int)(Math.random() * 300) + 30; 24 y = (int)(Math.random() * 200) + 130; 25 g.fillOval(x, y, 10, 10); 26 } 27 g.setColor(Color.orange); 28 y = 100; 29 for (i = 0; i < 40; i ++) 30 { 31 y += 5; 32 g.drawRect(30, 30, 320, y); 33 } 34 } 35 36 public static void main(String[] args) 37 { 38 TestGraphics f = new TestGraphics(); 39 f.setTitle("My First Graphics"); 40 f.setSize(400, 345); 41 f.setLocation(0, 0); 42 f.setVisible(true); 43 } 44 }

• 組件在容器中的擺放方式為布局。JAVA中不使用坐標這種絕對定位的方法，而是用布局管理器進行相對定位。優點是顯示界面能夠自動適應不同分辨率的屏幕。
• FlowLayout布局管理器從左到右排列組件，一行放滿后，再從第二行開始。它是容器類組件Panel的默認布局管理器。當容器大小發生變化時，容器上組建的排放位置會發生變化，規律是組件的大小不變，但是相對位置會發生變化。
• FlowLayout構造方法后兩個參數的單位都是像素。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestFlowLayout extends Frame 6 { 7 public static void main(String[] args) 8 { 9 TestFlowLayout f = new TestFlowLayout(); 10 11 f.setTitle("My FlowLayout Manager"); 12 f.setSize(200, 120); 13 14 FlowLayout fl = new FlowLayout(); 15 fl.setHgap(10); 16 f.setLayout(fl); 17 f.add(new Button("OK")); 18 f.add(new Button("Cancel")); 19 f.add(new Button("Password")); 20 f.add(new Button("Reset")); 21 f.setVisible(true); 22 } 23 }

• BorderLayout布局管理器按照東西南北中五個區域放置容器中的組件。它是容器類組件Window、Frame和Dialog等的默認布局管理器。當容器大小發生變化時，規律是組件的相對位置不變，大小發生變化。

1 package gUI; 2 3 import java.awt.*; 4 5 public class TestBorderLayout extends Frame 6 { 7 public static void main(String[] args) 8 { 9 TestBorderLayout frame1 = new TestBorderLayout(); 10 11 frame1.setTitle("My BorderLayout"); 12 frame1.setSize(200, 200); 13 14 BorderLayout border = new BorderLayout(5, 10); 15 16 frame1.setLayout(border); 17 frame1.add(new Button("South"), BorderLayout.SOUTH); 18 frame1.add(new Button("West"), BorderLayout.WEST); 19 frame1.add(new Button("North"), BorderLayout.NORTH); 20 frame1.add(new Button("East"), BorderLayout.EAST); 21 frame1.add(new Button("Center"), BorderLayout.CENTER); 22 frame1.setVisible(true); 23 } 24 }

• GridLayout布局管理器可以將容器分為若干個大小相等的矩形。
• 對于復雜的布局，有時還需要用到容器Panel組件。
• 事件源是產生事件的圖形組件。用戶對事件源進行的操作叫做事件。事件的屬性信息包含事件的名稱、來源、產生時間等。
• 事件處理過程包括事件的接收和事件的處理兩部分。事件的接收由系統負責。
• 事件發生后，系統把時間傳遞給事件處理程序的方式稱為事件模型。
• 層次事件模型首先傳遞給直接相關的組件；若組件沒對事件進行處理，則向上傳遞給組件所在的容器；若容器沒處理，則繼續向上傳遞給容器所在的容器。直至頂層容器。
• 委托事件模型中事件的傳遞由事件監聽器進行管理。任何事件處理程序首先向事件監聽器注冊，系統監聽到后就委托給事件監聽器。事件監聽器通過分析時間的屬性信息，把事件交給已注冊的相應事件處理器來處理。JDK1.1以后的版本都采用這個。
• ActionListener接口中只定義了一個處理按鈕單擊事件的方法actionPerformed()。
• JAVA中的組件就是事件源，它可以產生一個或多個事件。java.awt.AWTEvent類是所有事件類的父類，所以事件類都由它派生出來。
• 一個事件類對應一個事件監聽器接口，命名方法是：去掉事件類后邊的Event，換成Listener。不同的監聽器接口中定義了不同的處理方法。
• 一個事件處理器創建了以后，需要在程序中用語句來注冊。addListener()是Component類提供的方法。
• 與鍵盤事件KeyEvent相對應的鍵盤事件監聽器接口是KeyListener。當鍵盤剛按下去時，調用keyPressed()方法；鍵盤抬起來時，調用keyReleased()方法；鍵盤單擊一次時，調用keyTyped()方法。
• 程序可以有幾種方式實現事件監聽器接口中方法：類定義時加上implements，然后再類中實現接口中的方法；用內部類定義和實現事件監聽器接口。
• 若暫時不處理某個窗口操作（事件），可以用一個空語句實現相應的方法。
• 若要實現某個事件監聽器接口，就必須實現該事件監聽器接口中所以的方法，即使有些方法為空，也必須實現。為了簡化設計，JAVA為一些事件的Listener（監聽器）接口提供了事件適配器Adapter類。WindowAdapter類實現了WindowListener接口的所有方法（內容為空）。需要實現WindowListener接口時，只需要繼承WindowAdapter類，并覆蓋相應方法即可。

1 package gUI; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 6 public class PhoneBook extends WindowAdapter implements ActionListener, ItemListener 7 { 8 Frame f; 9 TextField tf1, tf2; 10 List l; 11 Button b1, b2; 12 13 public PhoneBook() 14 { 15 f = new Frame("PhoneBook"); 16 f.setSize(640, 480); 17 18 Panel p = new Panel(); 19 p.add(new Label("Name")); 20 tf1 = new TextField(10); 21 p.add(tf1); 22 p.add(new Label("PhoneNumber")); 23 tf2 = new TextField(20); 24 p.add(tf2); 25 b1 = new Button("Add"); 26 b2 = new Button("Delete"); 27 b1.addActionListener(this); 28 b2.addActionListener(this); 29 p.add(b1); 30 p.add(b2); 31 f.add(p, "North"); 32 33 l = new List(); 34 l.add("Name PhoneNumber"); 35 l.addItemListener(this); 36 f.add(l); 37 38 f.setVisible(true); 39 f.addWindowListener(this); 40 } 41 42 public void actionPerformed(ActionEvent e) 43 { 44 if (e.getSource() == b1) 45 l.add(tf1.getText() + " " + tf2.getText()); 46 47 if (e.getSource() == b2) 48 l.remove(l.getSelectedIndex()); 49 } 50 51 public void itemStateChanged(ItemEvent e) 52 { 53 String str = l.getSelectedItem(); 54 int i = str.indexOf(' '); 55 tf1.setText(str.substring(0, i)); 56 str = str.substring(i); 57 str = str.trim(); 58 tf2.setText(str); 59 } 60 61 public void windowClosing(WindowEvent e) 62 { 63 System.exit(0); 64 } 65 66 public static void main(String[] args) 67 { 68 new PhoneBook(); 69 } 70 } 1 package gUI; 2 3 import java.awt.*; 4 import java.awt.event.*; 5 6 public class RGBColor extends WindowAdapter implements TextListener 7 { 8 Frame f; 9 TextField tf1, tf2, tf3; 10 Panel p2; 11 12 public RGBColor() 13 { 14 f = new Frame("Mixed color"); 15 f.setSize(500, 200); 16 17 Panel p1 = new Panel(); 18 p2 = new Panel(); 19 f.add(p1, "North"); 20 f.add(p2); 21 p1.add(new Label("Red")); 22 tf1 = new TextField("255", 10); 23 p1.add(tf1); 24 25 p1.add(new Label("Green")); 26 tf2 = new TextField("0", 10); 27 p1.add(tf2); 28 29 p1.add(new Label("Blue")); 30 tf3 = new TextField("0", 10); 31 p1.add(tf3); 32 33 tf1.addTextListener(this); 34 tf2.addTextListener(this); 35 tf3.addTextListener(this); 36 37 p2.setBackground(new Color(255, 0, 0)); 38 39 f.setVisible(true); 40 f.addWindowListener(this); 41 } 42 43 public void textValueChanged(TextEvent e) 44 { 45 int r = (new Integer(tf1.getText()).intValue()); 46 int g = (new Integer(tf2.getText()).intValue()); 47 int b = (new Integer(tf3.getText()).intValue()); 48 49 if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) 50 p2.setBackground(new Color(r, g, b)); 51 } 52 53 public void windownClosing(WindowEvent e) 54 { 55 System.exit(0); 56 } 57 58 public static void main(String[] args) 59 { 60 new RGBColor(); 61 } 62 }

?

轉載于:https://www.cnblogs.com/pegasus923/p/4006500.html

總結

以上是生活随笔為你收集整理的学习笔记之Java程序设计实用教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。