1、Java學習筆記JASE SE知識復習1. 類是一種抽象的概念，對象是類的一種具體表示形式，是具體的概念。先有類，然后由類來生成對象（Object ）。對象又 叫做實例（Instance）。2. 類由兩大部分構成：屬性以及方法。屬性一般用名詞來表示， 方法一般用動詞來表示。 3. 如果一個java源文件中定義了多個類，那么這些類中最多只能有一個類是public 的，換句話說，定義的多個類可以都不是public 的。4. 在Java中進行方法的參數傳遞時，無論傳遞的是原生數據類型還是引用類型，參數傳遞方式統一是傳值（pass by value ）。 Java 中沒有傳引用（pass by ref

2、erence）的概念。5. 方法重載 （Overload）。表示兩個或多個方法名字相同，但方法參數不同。方法參數不同有兩層含義：1）參數個數不同。 2）參數類型不同。注意：方法的返回值對重載沒有任何影響。 6. 構造方法重載：只需看參數即可。如果想在一個構造方法中調用另外一個構造方法，那么可以使用this()的方式調用，this()括號中的參數表示目標構造方法的參數。this()必須要作為構造方法的第一條語句，換句話說，this()之前不能有任何可執行的代碼。 7. 繼承（Inheritence）：Java是單繼承的，意味著一個類只能從另一個類繼承（被繼承的類叫做父類【基類，base clas

3、s】，繼承的類叫做子類），Java中的繼承使用extends 關鍵字。 8. 當生成子類對象時，Java 默認首先調用父類的不帶參數的構造方法，然后執行該構造方法，生成父類的對象。接下來，再去調用子類的構造方法，生成子類的對象。【要想生成子類的對象，首先需要生成父類的對象，沒有父類對象就沒有子類對象。比如說：沒有父親，就沒有孩子】。 9. super 關鍵字：super 表示對父類對象的引用。10.如果子類使用super()顯式調用父類的某個構造方法，那么在執行的時候就會尋找與 super()所對應的構造方法而不會再去尋找父類的不帶參數的構造方法。與this 一樣，super 也必須要作為構造

4、方法的第一條執行語句，前面不能有其他可執行語句。 11.關于繼承的3 點： a) 父類有的，子類也有 b) 父類沒有的，子類可以增加 c) 父類有的，子類可以改變 12.關于繼承的注意事項 a) 構造方法不能被繼承 b) 方法和屬性可以被繼承 c) 子類的構造方法隱式地調用父類的不帶參數的構造方法 d) 當父類沒有不帶參數的構造方法時，子類需要使用super 來顯式地調用父類的構造方法，super 指的是對父類的引用 e) super 關鍵字必須是構造方法中的第一行語句。 13.方法重寫（Override）：又叫做覆寫，子類與父類的方法返回類型一樣、方法名稱一樣，參數一樣，這樣我們說子類與父類

5、的方法構成了重寫關系。 14.方法重寫與方法重載之間的關系：重載發生在同一個類內部的兩個或多個方法。重寫發生在父類與子類之間。 15. 當兩個方法形成重寫關系時，可以在子類方法中通super.run()形式調用父類的run()方法，其中super.run()不必放在第一行語句，因此此時父類對象已經構造完畢，先調用父類的run()方法還是先調用子類的run()方法是根據程序的邏輯決定的。 16.在定義一個類的時候，如果沒有顯式指定該類的父類，那么該類就會繼承于java.lang.Object 類（JDK 提供的一個類，Object 類是Java 中所有類的直接或間接父類）。 17. 多態（Pol

6、ymorphism）：我們說子類就是父類（玫瑰是花，男人是人），因此多態的意思就是：父類型的引用可以指向子類的對象。 1.多態：父類型的引用可以指向子類型的對象。 2. Parent p = new Child();當使用多態方式調用方法時，首先檢查父類中是否有sing()方法，如果沒有則編譯錯誤；如果有，再去調用子類的sing()方法。 3. 一共有兩種類型的強制類型轉換： a) 向上類型轉換（upcast）：比如說將Cat 類型轉換為Animal 類型，即將子類型轉換為父類型。對于向上類型轉換，不需要顯式指定。 b) 向下類型轉換（downcast）：比如將Animal 類型轉換為Cat

7、類型。即將父類型轉換為子類型。對于向下類型轉換，必須要顯式指定 （必須要使用強制類型轉換）。 4. 抽象類（abstract class）：使用了abstract 關鍵字所修飾的類叫做抽象類。抽象類無法實例化，也就是說，不能new 出來一個抽象類的對象（實例）。 5. 抽象方法（abstract method ）：使用abstract 關鍵字所修飾的方法叫做抽象方法。抽象方法需要定義在抽象類中。相對于抽象方法，之前所定義的方法叫做具體方法（有聲明，有實現）。 6. 如果一個類包含了抽象方法，那么這個類一定是抽象類。 7. 如果某個類是抽象類，那么該類可以包含具體方法（有聲明、有實現）。 8.

8、如果一個類中包含了抽象方法，那么這個類一定要聲明成abstract class，也 就是說，該類一定是抽象類；反之，如果某個類是抽象類，那么該類既可以包含抽象方法，也可以包含具體方法。 9. 無論何種情況，只要一個類是抽象類，那么這個類就無法實例化。 10. 在子類繼承父類（父類是個抽象類）的情況下，那么該子類必須要實現父類中所定義的所有抽象方法；否則，該子類需要聲明成一個abstract class。 11. 接口（interface）：接口的地位等同于 class，接口中的所有方法都是抽象方法。在聲明接口中的方法時，可以使用abstract 關鍵字，也可以不使用。通常情況下，都會省略掉ab

9、stract 關鍵字。 12. 可以將接口看作是特殊的抽象類（抽象類中可以有具體方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具體方法）。 13. 類可以實現接口。實現使用關鍵字implements 表示，代表了某個類實現了某個接口。 14. 一個類實現了某個接口，那么該類必須要實現接口中聲明的所有方法。如果該類是個抽象類，那么就無需實現接口中的方法了。 15. Java 是單繼承的，也就是說某個類只能有唯一一個父類；一個類可以實現多個接口，多個接口之間使用逗號分隔。 16. 多態：所謂多態，就是父類型的引用可以指向子類型的對象，或者接口類型的引用可以指向實現該接口的類的實例。關于接口

10、與實現接口的類之間的強制類型轉換方式與父類和子類之間的強制類型轉換方式完全一樣。 17. static 關鍵字：可以用于修飾屬性，也可以用于修飾方法，還可以用于修飾類（后面的課程講） 18. static 修飾屬性：無論一個類生成了多少個對象，所有這些對象共同使用唯一一份靜態的成員變量；一個對象對該靜態成員變量進行了修改，其他對象的該靜態成員變量的值也會隨之發生變化。如果一個成員變量是static的，那么我們可以通過類名.成員變量名的方式來使用它（推薦使用這種方式）。 19. static 修飾方法：static 修飾的方法叫做靜態方法。對于靜態方法來說，可以使用類名.方法名的方式來訪問。 2

11、0. 靜態方法只能繼承，不能重寫（Override）。 21. final 關鍵字：final 可以修飾屬性、方法、類。 22. final 修飾類：當一個類被final 所修飾時，表示該類是一個終態類，即不能被繼承。 23. final 修飾方法：當一個方法被final 所修飾時，表示該方法是一個終態方法，即不能被重寫（Override）。 24. final 修飾屬性：當一個屬性被final 所修飾時，表示該屬性不能被改寫。 25. 當final 修飾一個原生數據類型時，表示該原生數據類型的值不能發生變化（比如說不能從10 變為20）；如果final 修飾一個引用類型時，表示該引用類型不能

12、再指向其他對象了，但該引用所指向的對象的內容是可以發生變化的。 26. 對于final 類型成員變量，一般來說有兩種賦初值方式： a) 在聲明final 類型的成員變量時就賦上初值 b) 在聲明final 類型的成員變量時不賦初值，但在類的所有構造方法中都為其賦上初值。 27. static 代碼塊：靜態代碼塊。靜態代碼塊的作用也是完成一些初始化工作。首先執行靜態代碼塊，然后執行構造方法。靜態代碼塊在類被加載的時候執行，而構造方法是在生成對象的時候執行；要想調用某個類來生成對象，首先需要將類加載到Java 虛擬機上（JVM ），然后由JVM 加載這個類來生成對象。 28. 類的靜態代碼塊只會執

13、行一次，是在類被加載的時候執行的，因為每個類只會被加載一次，所以靜態代碼塊也只會被執行一次；而構造方法則不然，每次生成一個對象的時候都會調用類的構造方法，所以new 一次就會調用構造方法一次。 29. 如果繼承體系中既有構造方法，又有靜態代碼塊，那么首先執行最頂層的類的靜態代碼塊，一直執行到最底層類的靜態代碼塊，然后再去執行最頂層類的構造方法，一直執行到最底層類的構造方法。注意：靜態代碼塊只會執行 一次。 30. 不能在靜態方法中訪問非靜態成員變量；可以在靜態方法中訪問靜態的成員 變量。可以在非靜態方法中訪問靜態的成員變量。 31. 總結：靜態的只能訪問靜態的；非靜態的可以訪問一切。 32.

14、不能在靜態方法中使用this 關鍵字。 1. 接口中所聲明的方法都是抽象方法。接口中的方法都是public 的。 2. 接口中也可以定義成員變量。接口中的成員變量都是public、final、static 的。 3. 一個類不能既是final，又是abstract 的。因為abstract 的主要目的是定義一種約定，讓子類去實現這種約定，而final 表示該類不能被繼承，這樣abstract 希望該類可以被繼承而final 明確說明該類不能被繼承，兩者矛盾。因此一個類不能既是final 的， 又是abstract 的。 4. Design Pattern （設計模式）。單例模式（Singlet

15、on）：表示一個類只會生成唯一的一個對象。 5. 包（package）。用于將完成不同功能的類分門別類，放在不同的目錄（包）下。包的命名規則：將公司域名反轉作為包名。，com.shengsiyuan （包名），對于包名：每個字母都需要小寫。如果定義類的時候沒有使用package，那么Java 就認為我們所定義的類位于默認包里面（default package）。 6. 編譯帶有package 聲明的Java 源文件有兩種方式： a) 直接編譯，然后根據類中所定義的包名，逐一手工建立目錄結構，最后將生成的class文件放到該目錄結構中（很少使用，比較麻煩）。 b) 使用編譯參數d，方式為java

16、c d .源文件.java，這樣在編譯后，編譯器會自動幫助我們建立好包所對應的目錄結構。 7. 有兩個包名，分別是aa.bb.cc 與aa.bb.cc.dd，那么我們稱后者為前者的子包。 8. 導入（import），將使用package 分離的各個類導入回來，讓編譯器能夠找到所需要的類。 9. import 的語法：import com.shengsiyuan.PackageTest; 10. import com.shengsiyuan.*，表示導入com.shengsiyuan 包下面的所有類。 11. import aa.bb.*并不會導入aa.bb.cc 包下面的類。這時需要這樣寫：

17、import aa.bb.*; import aa.bb.cc.*; 12. 關于package、import、class 的順序問題： a) 首先需要定義包（package），可選 b) 接下來使用import 進行導入，可選 c) 然后才是class 或interface 的定義。 13. 如果兩個類在同一個包下面，那么則不需要導入，直接使用即可。 14. 訪問修飾符 （access modifier）。 1） public （公共的）：被public 所修飾的屬性和方法可以被所有類訪問。 2） protected （受保護的）：被protected 所修飾的屬性和方法可以在類內部、相同包

18、以及該類的子類所訪問。 3） private（私有的）：被private 所修飾的屬性和方法只能在該類內部使用 4 ） 默認的（不加任何訪問修飾符）：在類內部以及相同包下面的類所使用。 15. instanceof：判斷某個對象是否是某個類的實例。語法形式：引用名 instanceof 類名（接口名），返回一個boolean 值。 16. People people = new Man(); 17. System.out.println(people instanceof People); /結果為true，因為Man 是People 的子類，根據繼承，子類就是父類，因此Man 也可以看作是P

19、eople 的實例。 18. 相等性的比較 （=） 1） 對于原生數據類型來說，比較的是左右兩邊的值是否相等。 2） 對于引用類型來說，比較左右兩邊的引用是否指向同一個對象，或者說左右兩邊的引用地址是否相同。 19. java.lang.Object 類。java.lang 包在使用的時候無需顯式導入，編譯時由編譯器自動幫助我們導入。 20. API （Application Programming Interface ），應用編程接口。 21. 當打印引用時，實際上會打印出引用所指對象的toString()方法的返回值，因為每個類都直接或間接地繼承自Object，而Object 類中定義了t

20、oString()，因此每個類都有toString()這個方法。 22. 關于進制的表示：16 進制，逢16 進一，16 進制的數字包括：09，A,B,C,D,E,F， 23. equals()方法，該方法定義在Object 類當中，因此Java 中的每個類都具有該方法，對于Object 類的equals()方法來說，它是判斷調用equals()方法的引用與傳進來的引用是否一致，即這兩個引用是否指向的是同一個對象。對于Object 類的equals()方法來說，它等價于=。 24. 對于String類的equals()方法來說，它是判斷當前字符串與傳進來的字符串的內容是否一致。 25. 對于S

21、tring 對象的相等性判斷來說，請使用equals()方法，而不要使用=。 26. String 是常量，其對象一旦創建完畢就無法改變。當使用+拼接字符串時，會生成新的String 對象，而不是向原有的String 對象追加內容。 27. String Pool （字符串池） 28. String s = “aaa”; （采用字面值方式賦值） 1) 查找String Pool 中是否存在“aaa”這個對象，如果不存在，則在String Pool 中創建一個“aaa”對象，然后將String Pool 中的這個“aaa”對象的地址返回來，賦給引用變量s，這樣s 會指向String Pool 中

22、的這個“aaa”字符串對象 2) 如果存在，則不創建任何對象，直接將String Pool 中的這個“aaa”對象地址返回來，賦給s 引用。 29. String s = new String(“aaa”); 1) 首先在String Pool 中查找有沒有“aaa”這個字符串對象，如果有，則不在String Pool中再去創建“aaa”這個對象了，直接在堆中（heap）中創建一個“aaa”字符串對象，然后將堆中的這個“aaa”對象的地址返回來，賦給s 引用，導致s 指向了堆中創建的這個“aaa”字符串對象。 2) 如果沒有，則首先在String Pool 中創建一個“aaa “對象，然后再在

23、堆中（heap）創建一個”aaa “對象，然后將堆中的這個”aaa “對象的地址返回來，賦給s 引用，導致s 指向了堆中所創建的這個”aaa “對象。 1. 包裝類（Wrapper Class ）。針對于原生數據類型的包裝。所有的包裝類（8個）位于java.lang包下。Java 中的8 個包裝類分別是：Byte, Short, Integer, Long, Float, Double, Character, Boolean。他們的使用方式都是一樣的，可以實現原生數據類型與包裝類型的雙向轉換2.數組（Array ）：相同類型數據的集合就叫做數組。 3. 如何定義數組。type變量名= new

24、type數組中元素的個數;可以按照下列方式定義長度為10 的數組： int a = new int10; 或者 int a = new int10; 4. 數組中的元素索引是從0 開始的。對于數組來說，最大的索引=數組的長度 1。 5. 定義數組的第3 種方式：type變量名 = new type逗號分隔的初始化值列表; 6. Java 中的每個數組都有一個名為length 的屬性，表示數組的長度。length 屬性是public，final，int 的。數組長度一旦確定，就不能改變大小。 7. int a = new int10，其中a 是一個引用，它指向了生成的數組對象的首地址，數組中每個

25、元素都是int 類型，其中僅存放數據值本身。 8. 二維數組。二維數組是一種平面的二維結構，本質上是數組的數組。二維數組的定義方式：type a = new type23; 9. 三維數組。type a = new type234; 10. 冒泡排序。（掌握交換排序，快速排序的原理與實現方式） 11. 二分查找（Binary Search）：待查找的數組要有序。 12. 隨機生成50 個數字（整數），每個數字的范圍是10, 50，統計每個數字出現的次數以及出現次數最多的數字與它的個數，最后將每個數字及其出現次數打印出來，如果某個數字出現次數為0，則不要打印它。打印時按照數字的升序排列。1. 對

26、于Java 中的常量的命名規則：所有單詞的字母都是大寫，如果有多個單詞，那么使用下劃線連接即可。比如說： public static final int AGE_0F_PERSON = 20; 2. 在Java 中聲明final 常量時通常都會加上static 關鍵字，這樣對象的每個實例都會訪問唯一一份常量值。 3. IDE （Integrated Development Environment），集成開發環境。 1） NetBeans。/，最高版本是6.9.1 2） JBuilder 。 3） Intellij IDEA 4） Eclipse （日蝕、月蝕

27、），最高版本3.6.1 4. 集合中存放的依然是對象的引用而不是對象本身。 5. ArrayList 底層采用數組實現，當使用不帶參數的構造方法生成ArrayList 對象時，實際上會在底層生成一個長度為10 的Object 類型數組 6. 如果增加的元素個數超過了10 個，那么ArrayList 底層會新生成一個數組，長度為原數組的1.5 倍+1，然后將原數組的內容復制到新數組當中，并且后續增加的內容都會放到新數組當中。當新數組無法容納增加的元素時，重復該過程。 7. 對于ArrayList 元素的刪除操作，需要將被刪除元素的后續元素向前移動，代價比較高。 8. 集合當中只能放置對象的引用，

28、無法放置原生數據類型，我們需要使用原生數據類型的包裝類才能加入到集合當中。9. 集合當中放置的都是Object 類型，因此取出來的也是Object 類型，那么必須要使用強制類型轉換將其轉換為真正的類型（放置進去的類型）。 10. 關于ArrayList 與LinkedList 的比較分析 a) ArrayList 底層采用數組實現，LinkedList 底層采用雙向鏈表實現。 b) 當執行插入或者刪除操作時，采用LinkedList 比較好。 c) 當執行搜索操作時，采用ArrayList 比較好。 1.當向ArrayList添加一個對象時，實際上就是將該對象放置到了ArrayList底層所維

29、護的數組當中；當向LinkedList中添加一個對象時，實際上LinkedList內部會生成一個Entry 對象，該Entry 對象的結構為： Entry Entry previous; Object element; Entry next; 其中的Object 類型的元素element 就是我們向LinkedList 中所添加的元素，然后Entry又構造好了向前與向后的引用previous、next，最后將生成的這個Entry 對象加入到了鏈表當中。換句話說，LinkedList 中所維護的是一個個的Entry 對象。 2. 關于Object 類的equals 方法的特點 a) 自反性：x.

30、equals(x)應該返回true b) 對稱性：x.equals(y)為true，那么y.equals(x)也為true 。 c) 傳遞性：x.equals(y)為true 并且y.equals(z)為true，那么x.equals(z)也應該為true 。 d) 一致性：x.equals(y)的第一次調用為true，那么x.equals(y)的第二次、第三次、第n次調用也應該為true，前提條件是在比較之間沒有修改x 也沒有修改y。 e) 對于非空引用x，x.equals(null)返回false 。 3. 關于Object 類的hashCode()方法的特點： a) 在Java 應用的一

31、次執行過程當中，對于同一個對象的hashCode 方法的多次調用，他們應該返回同樣的值 （前提是該對象的信息沒有發生變化）。 b) 對于兩個對象來說，如果使用equals 方法比較返回true，那么這兩個對象的hashCode值一定是相同的。 c) 對于兩個對象來說，如果使用equals 方法比較返回false，那么這兩個對象的hashCode值不要求一定不同 （可以相同，可以不同），但是如果不同則可以提高應用的性能。 d) 對于Object類來說，不同的Object 對象的hashCode值是不同的（Object 類的hashCode值表示的是對象的地址）。 4. 當使用HashSet 時，

32、hashCode()方法就會得到調用，判斷已經存儲在集合中的對象的hash code 值是否與增加的對象的hashcode 值一致；如果不一致，直接加進去；如果一致，再進行equals 方法的比較，equals 方法如果返回true，表示對象已經加進去了，就不會再增加新的對象，否則加進去。 5. 如果我們重寫equals 方法，那么也要重寫hashCode 方法，反之亦然。 6. Map （映射）：Map 的keySet()方法會返回key 的集合，因為Map 的鍵是不能重復的，因此keySet()方法的返回類型是Set；而Map 的值是可以重復的，因此values()方法的返回類型是Coll

33、ection，可以容納重復的元素。 注：HashMap是異步處理機制，而Hashtable是同步的；1. 有這樣一個類：public class PersonPrivate int id;Private String name;Private int age; / getter and setter 要求：假如有若干個類Person 對象存在一個List 當中，對他們進行排序，分別按照名字、年齡、id 進行排序 （要有正序與倒序兩種排序方式）。假如年齡或者姓名重復，按照id的正序進行排序。要求使用策略模式進行。 2. HashSet 底層是使用HashMap 實現的。當使用add 方法將對象添

34、加到Set 當中時，實際上是將該對象作為底層所維護的Map 對象的key，而value 則都是同一個Object對象（該對象我們用不上）； 3. HashMap 底層維護一個數組，我們向HashMap 中所放置的對象實際上是存儲在該數組當中； 4. 當向HashMap 中put 一對鍵值時，它會根據key 的hashCode 值計算出一個位置，該位置就是此對象準備往數組中存放的位置。 5. 如果該位置沒有對象存在，就將此對象直接放進數組當中；如果該位置已經有對象存在了，則順著此存在的對象的鏈開始尋找（Entry 類有一個Entry 類型的next 成員變量，指向了該對象的下一個對象），如果此鏈

35、上有對象的話，再去使用equals方法進行比較，如果對此鏈上的某個對象的equals 方法比較為false，則將該對象放到數組當中，然后將數組中該位置以前存在的那個對象鏈接到此對象的后面。 6. HashMap 的內存實現布局： 7. 所謂泛型：就是變量類型的參數化。1. 當遍歷集合或數組時，如果需要訪問集合或數組的下標，那么最好使用舊式的方式來實現循環或遍歷，而不要使用增強的for 循環，因為它丟失了下標信息。 2. Integer 類有一個緩存，它會緩存介于-128127 之間的整數。 3. 可變參數：可變參數本質上就是一個數組，對于某個聲明了可變參數的方法來說，我們既可以傳遞離散的值，也

36、可以傳遞數組對象。但如果將方法中的參數定義為數組，那么只能傳遞數組對象而不能傳遞離散的值。 4. 可變參數必須要作為方法參數的最后一個參數，即一個方法不可能具有兩個或兩個以上的可變參數。 5. 枚舉（Enum）：我們所定義的每個枚舉類型都繼承自java.lang.Enum 類，枚舉中的每個成員默認都是public static final 的。 6. 而每個枚舉的成員其實就是您定義的枚舉類型的一個實例（Instance）。換句話說，當定義了一個枚舉類型后，在編譯時刻就能確定該枚舉類型有幾個實例，分別是什么。在運行期間我們無法再使用該枚舉類型創建新的實例了，這些實例在編譯期間就已經完全確定下來了

37、。 7. 靜態導入： a) import static mon.Common.Age; b) import static mon.Common.output; 8. 表示導入Common 類中的靜態成員變量AGE 以及靜態方法output。注意：使用import static 時，要一直導入到類中的靜態成員變量或靜態方法。 9. Java 中，無論生成某個類的多少個對象，這些對象都會對應于同一個Class 對象。1. 要想使用反射，首先需要獲得待處理類或對象所對應的Class對象。 2. 獲取某個類或某個對象所對應的Class 對象的常用的3 種方式： a)使用Class類的靜態方法forNa

38、me：Class.forName(“java.lang.String”); b) 使用類的.class 語法：String.class; c) 使用對象的getClass()方法：String s = “aa”; Class<?> clazz = s.getClass(); 3. 若想通過類的不帶參數的構造方法來生成對象，我們有兩種方式： a) 先獲得Class 對象，然后通過該Class 對象的newInstance()方法直接生成即可： Class<?> classType = String.class; Object obj = classType.newInst

39、ance(); b) 先獲得Class 對象，然后通過該對象獲得對應的Constructor 對象，再通過該Constructor對象的newInstance()方法生成： Class<?> classType = Customer.class; Constructor cons = classType.getConstructor(new Class); Object obj = cons.newInstance(new Object); 4. 若想通過類的帶參數的構造方法生成對象，只能使用下面這一種方式： Class<?> classType = Customer.

40、class; Constructor cons = classType.getConstructor(new ClassString.class, int.class); Object obj = cons.newInstance(new Object“hello”, 3); 5. Integer.TYPE 返回的是int，而Integer.class 返回的是Integer 類所對應的Class 對象。1. 靜態代理模式圖示 2. Java 注解（Annotation ）： a) Override 注解表示子類要重寫（override）父類的對應方法。 b) Deprecated 注解表示方

41、法是不建議被使用的。 c) SuppressWarnings 注解表示抑制警告。 3. 自定義注解：當注解中的屬性名為value時，在對其賦值時可以不指定屬性的名稱而直接寫上屬性值即可；除了value 以外的其他值都需要使用name=value 這種賦值方式，即明確指定給誰賦值。 4.當我們使用interface關鍵字定義一個注解時，該注解隱含地繼承了 java.lang.annotation.Annotation 接口；如果我們定義了一個接口，并且讓該接口繼承自Annotation，那么我們所定義的接口依然還是接口而不是注解；Annotation本身是接口而不是注解。可以與Enum 類比。

42、5. JUnit （3.8、4.x ）：Keep the bar green to keep the code clean. 6. 我的名言：沒有反射，很多框架就不存在了。（No Reflection，No most frameworks）。 7. JUnit4 的執行的一般流程： a) 首先獲得待測試類所對應的Class 對象。 b) 然后通過該Class 對象獲得當前類中所有public 方法所對應的Method 數組。 c) 遍歷該Method 數組，取得每一個Method 對象 d) 調用每個Method 對象的isAnnotationPresent(Test.class)方法，判斷該

43、方法是否被Test注解所修飾。 e) 如果該方法返回true，那么調用method.invoke()方法去執行該方法，否則不執行。 8. 單元測試不是為了證明你是對的，而是證明你沒有錯誤。 9. Writing Secure Code （編寫安全的代碼）：Input is evil。 10. 異常（Exception）。 11. Java 中的異常分為兩大類： a) Checked exception （非 Runtime Exception） b) Unchecked exception （Runtime Exception） 12. Java中所有的異常類都會直接或間接地繼承自Except

44、ion。 13. RuntimeException 類也是直接繼承自Exception 類，它叫做運行時異常，Java中所有的運行時異常都會直接或間接地繼承自RuntimeException。 14. Java中凡是繼承自Exception 而不是繼承自RuntimeException的類都是非運行時異常。 15. 異常處理的一般結構是： try catch(Exception e) finally 無論程序是否出現異常，finally 塊中的代碼都是會被執行的。 16. 對于非運行時異常（checked exception），必須要對其進行處理，處理方式有兩種： 第一種是使用try. cat

45、chfinally 進行捕獲；第二種是在調用該會產生異常的方法所在的方法聲明throws Exception 17. 對于運行時異常（runtime exception），我們可以不對其進行處理，也可以對其進行處理。推薦不對其進行處理。 18. NullPointerException 是空指針異常，出現該異常的原因在于某個引用為null，但你卻調用了它的某個方法。這時就會出現該異常。 1. 所謂自定義異常，通常就是定義了一個繼承自Exception 類的子類，那么這個類就是一個自定義異常類。通常情況下，我們都會直接繼承自Exception 類，一般不會繼承某個運行時的異常類。 2. 我們可以

46、使用多個catch 塊來捕獲異常，這時需要將父類型的catch 塊放到子類型的catch 塊之后，這樣才能保證后續的catch 可能被執行，否則子類型的catch 將永遠無法到達，Java編譯器會報編譯錯誤；如果多個 catch塊的異常類型是獨立的(MyException, MyException2)，那么誰前誰后都是可以的。 3. 如果try 塊中存在return 語句，那么首先也需要將finally 塊中的代碼執行完畢，然后方法再返回。 4. 如果try塊中存在 System.exit(0)語句，那么就不會執行 finally 塊中的代碼，因為System.exit(0)會終止當前運行的J

47、ava 虛擬機，程序會在虛擬機終止前結束執行。 5. GUI （Graphical User Interface），圖形用戶界面。 6. AWT （Abstract Window Toolkit ），抽象窗口工具集，第一代的Java GUI 組件，是重量級的。7. Swing，不依賴于底層細節，輕量級的組件。1. 內部類（Inner Class），內部類共分為4 種。 2. 靜態內部類（static inner class）：只能訪問外部類的靜態成員變量與靜態方法，生成靜態內部類對象的方式為： OuterClass.InnerClass inner = new OuterClass.Inner

48、Class(); 3. 成員內部類（member inner class）：可以訪問外部類的靜態與非靜態的方法與成員變量。生成成員內部類對象的方式為： OuterClass.InnerClass inner = new OuterClass().new InnerClass(); 4. 若想在局部內部類中訪問外部類的成員變量，語法為：OuterClass.this.a; 5. 局部內部類（Local Inner Class）：定義在方法當中，只能訪問方法中聲明的final 類型的變量。 6. 匿名內部類（Anonymous Inner Class ）：匿名內部類會隱式地繼承一個父類或實現一個接

49、口。 7. 所謂遞歸（Recursion），就是方法調用自身。對于遞歸來說，一定有一個出口，讓遞歸結束，只有這樣才能保證不出現死循環。 8. 作業：給定任意一個目錄，以樹形方式展現出該目錄中的所有子目錄和文件。另外，在展現的時候將目錄排在上面，文件排在下面。每一層要加上縮進。1. 一個類若想被序列化，則需要實現java.io.Serializable 接口，該接口中沒有定義任何方法，是一個標識性接口（Marker Interface），當一個類實現了該接口，就表示這個類的對象是可以序列化的。 2. 在序列化時，static 變量是無法序列化的；如果A 包含了對B 的引用，那么在序列化 A的時候

50、也會將B 一并地序列化；如果此時A 可以序列化，B 無法序列化，那么當序列化A 的時候就會發生異常，這時就需要將對B 的引用設為transient，該關鍵字表示變量不會被序列化。 3.當我們在一個待序列化/反序列化的類中實現了以上兩個private 方法（方法聲明要與上面的保持完全的一致），那么就允許我們以更加底層、更加細粒度的方式控制序列化/反序列化的過程。 4. Java 中如果我們自己沒有產生線程，那么系統就會給我們產生一個線程 （主線程，main 方法就在主線程上運行），我們的程序都是由線程來執行的。 5. 進程：執行中的程序（程序是靜態的概念，進程是動態的概念）。 6. 線程的實現有

51、兩種方式，第一種方式是繼承Thread 類，然后重寫run 方法；第二種是實現Runnable 接口，然后實現其run 方法。 7. 將我們希望線程執行的代碼放到run 方法中，然后通過start 方法來啟動線程，start方法首先為線程的執行準備好系統資源，然后再去調用run 方法。當某個類繼承了Thread 類之后，該類就叫做一個線程類。 8. 一個進程至少要包含一個線程。 9. 對于單核CPU來說，某一時刻只能有一個線程在執行（微觀串行），從宏觀角度來看，多個線程在同時執行 （宏觀并行）。 10. 對于雙核或雙核以上的CPU 來說，可以真正做到微觀并行。 11. 1) Thread 類也

52、實現了Runnable 接口，因此實現了Runnable 接口中的run 方法； 2)當生成一個線程對象時，如果沒有為其設定名字，那么線程對象的名字將使用如下 形式：Thread-number,該number 將是自動增加的，并被所有的Thread 對象所共享（因為它是static 的成員變量）。 3)當使用第一種方式來生成線程對象時，我們需要重寫run 方法，因為Thread 類的run方法此時什么事情也不做。 4) 當使用第二種方式來生成線程對象時，我們需要實現Runnable 接口的run 方法，然后使用new Thread(new MyThread() （假如MyThread 已經實現

53、了Runnable 接口）來生成線程對象，這時的線程對象的run 方法就會調用MyThread 類的run 方法，這樣我們自己編寫的run 方法就執行了。 12. 關于成員變量與局部變量：如果一個變量是成員變量，那么多個線程對同一個對象的成員變量進行操作時，他們對該成員變量是彼此影響的（也就是說一個線程對成員變量的改變會影響到另一個線程）。 13. 如果一個變量是局部變量，那么每個線程都會有一個該局部變量的拷貝，一個線程對該局部變量的改變不會影響到其他的線程。 14. 停止線程的方式：不能使用Thread 類的stop 方法來終止線程的執行。一般要設定一個變量，在run 方法中是一個循環，循環

54、每次檢查該變量，如果滿足條件則繼續執行，否則跳出循環，線程結束。 15. 不能依靠線程的優先級來決定線程的執行順序。 16. synchronized 關鍵字：當synchronized 關鍵字修飾一個方法的時候，該方法叫做同步方法。 17. Java 中的每個對象都有一個鎖（lock）或者叫做監視器（monitor），當訪問某個對象的synchronized 方法時，表示將該對象上鎖，此時其他任何線程都無法再去訪問該synchronized 方法了，直到之前的那個線程執行方法完畢后（或者是拋出了異常），那么將該對象的鎖釋放掉，其他線程才有可能再去訪問該synchronized 方法。 18.

55、 如果一個對象有多個 synchronized方法，某一時刻某個線程已經進入到了某個synchronized 方法，那么在該方法沒有執行完畢前，其他線程是無法訪問該對象的任何synchronized 方法的。 1. 如果某個synchronized 方法是static的，那么當線程訪問該方法時，它鎖的并不是synchronized 方法所在的對象，而是synchronized 方法所在的對象所對應的Class 對象，因為Java 中無論一個類有多少個對象，這些對象會對應唯一一個Class 對象，因此當線程分別訪問同一個類的兩個對象的兩個static，synchronized 方法時，他們的執行

56、順序也是順序的，也就是說一個線程先去執行方法，執行完畢后另一個線程才開始執行。 2. synchronized 塊，寫法： synchronized(object) 表示線程在執行的時候會對object 對象上鎖。 3. synchronized 方法是一種粗粒度的并發控制，某一時刻，只能有一個線程執行該synchronized 方法;synchronized 塊則是一種細粒度的并發控制，只會將塊中的代碼同步，位于方法內、synchronized 塊之外的代碼是可以被多個線程同時訪問到的。 4. 死鎖（deadlock） 5. wait 與notify 方法都是定義在Object 類中，而且是

57、final 的，因此會被所有的Java類所繼承并且無法重寫。這兩個方法要求在調用時線程應該已經獲得了對象的鎖，因此對這兩個方法的調用需要放在synchronized 方法或塊當中。當線程執行了wait方法時，它會釋放掉對象的鎖。 6. 另一個會導致線程暫停的方法就是Thread 類的sleep 方法，它會導致線程睡眠指定的毫秒數，但線程在睡眠的過程中是不會釋放掉對象的鎖的。1. 對于單例模式（Singleton）來說，如果在getInstance()方法中生成Singleton 實例則可能會產生同步問題，即可能會生成兩個不同的對象。 1.客戶端與服務器端之間的通信全部采用XML 實現： 1）用戶登錄 （type=1 ）： <?xml version="1.0" encoding="utf-8"?> <message> <type>1</type> <user>zhangsan</user> </message> 2）服務器端向所有