《JAVA核心知識》學習筆記（5. JAVA 基礎）-4

5.1.1. JAVA 異常分類及處理
5.1.1.1. 概念
若是某個方法不能按照正常的途徑完成任務，就能夠經過另外一種路徑退出方法。在這種狀況下
會拋出一個封裝了錯誤信息的對象。此時，這個方法會馬上退出同時不返回任何值。另外，調用
這個方法的其餘代碼也沒法繼續執行，異常處理機制會將代碼執行交給異常處理器

 

 

 

 

Throwable 是 Java 語言中全部錯誤或異常的超類。下一層分爲 Error 和 Exception
Error
1. Error 類是指 java 運行時系統的內部錯誤和資源耗盡錯誤。應用程序不會拋出該類對象。若是
出現了這樣的錯誤，除了告知用戶，剩下的就是盡力使程序安全的終止。
Exception（RuntimeException、 CheckedException）
2. Exception 又 有 兩 個 分 支 ， 一 個 是 運 行 時 異 常 RuntimeException ， 一 個 是
CheckedException。
RuntimeException 如 ： NullPointerException 、 ClassCastException ； 一 個 是 檢 查 異 常
CheckedException，如 I/O 錯誤致使的 IOException、 SQLException。 RuntimeException 是
那些可能在 Java 虛擬機正常運行期間拋出的異常的超類。 若是出現 RuntimeException，那麼一
定是程序員的錯誤.
 

檢查異常 CheckedException： 通常是外部錯誤，這種異常都發生在編譯階段， Java 編譯器會強
製程序去捕獲此類異常，即會出現要求你把這段可能出現異常的程序進行 try catch，該類異常一
般包括幾個方面：
1. 試圖在文件尾部讀取數據
2. 試圖打開一個錯誤格式的 URL
3. 試圖根據給定的字符串查找 class 對象，而這個字符串表示的類並不存在
 

5.1.1.3. 異常的處理方式
遇到問題不進行具體處理，而是繼續拋給調用者 （throw,throws）
拋出異常有三種形式，一是 throw,一個 throws，還有一種系統自動拋異常
 

5.1.1.4. Throw 和 throws 的區別：
位置不一樣
1. throws 用在函數上，後面跟的是異常類，能夠跟多個； 而 throw 用在函數內，後面跟的
是異常對象。
功能不一樣：
2. throws 用來聲明異常，讓調用者只知道該功能可能出現的問題，能夠給出預先的處理方
式； throw 拋出具體的問題對象，執行到 throw，功能就已經結束了，跳轉到調用者，並
將具體的問題對象拋給調用者。也就是說 throw 語句獨立存在時，下面不要定義其餘語
句，由於執行不到。
3. throws 表示出現異常的一種可能性，並不必定會發生這些異常； throw 則是拋出了異常，
執行 throw 則必定拋出了某種異常對象。

5.1.2. JAVA 反射
5.1.2.1. 動態語言
動態語言，是指程序在運行時能夠改變其結構：新的函數能夠引進，已有的函數能夠被刪除等結
構上的變化。好比常見的 JavaScript 就是動態語言，除此以外 Ruby,Python 等也屬於動態語言，
而 C、 C++則不屬於動態語言。 從反射角度說 JAVA 屬於半動態語言。
 

在 Java 中的反射機制是指在運行狀態中，對於任意一個類都可以知道這個類全部的屬性和方法；
而且對於任意一個對象，都可以調用它的任意一個方法；這種動態獲取信息以及動態調用對象方
法的功能成爲 Java 語言的反射機制。
 

5.1.2.3. 反射的應用場合
編譯時類型和運行時類型
在 Java 程序中許多對象在運行是都會出現兩種類型：編譯時類型和運行時類型。 編譯時的類型由
聲明對象時實用的類型來決定，運行時的類型由實際賦值給對象的類型決定 。 如：
Person p=new Student();
其中編譯時類型爲 Person，運行時類型爲 Student
 

的編譯時類型沒法獲取具體方法
程序在運行時還可能接收到外部傳入的對象， 該對象的編譯時類型爲 Object,可是程序有須要調用
該對象的運行時類型的方法。爲了解決這些問題， 程序須要在運行時發現對象和類的真實信息。
然而，若是編譯時根本沒法預知該對象和類屬於哪些類，程序只能依靠運行時信息來發現該對象
和類的真實信息，此時就必須使用到反射了
 

5.1.2.4. Java 反射 API
反射 API 用來生成 JVM 中的類、接口或則對象的信息。
1. Class 類：反射的核心類，能夠獲取類的屬性，方法等信息。
2. Field 類： Java.lang.reflec 包中的類， 表示類的成員變量，能夠用來獲取和設置類之中的屬性
值。
3. Method 類： Java.lang.reflec 包中的類，表示類的方法，它能夠用來獲取類中的方法信息或
者執行方法。
4. Constructor 類： Java.lang.reflec 包中的類，表示類的構造方法。
5.1.2.5. 反射使用步驟（獲取 Class 對象、調用對象方法）
1. 獲取想要操做的類的 Class 對象，他是反射的核心，經過 Class 對象咱們能夠任意調用類的方
法。
2. 調用 Class 類中的方法，既就是反射的使用階段。
3. 使用反射 API 來操做這些信息

 

5.1.2.6. 獲取 Class 對象的 3 種方法
調用某個對象的 getClass()方法
Person p=new Person();
Class clazz=p.getClass();
調用某個類的 class 屬性來獲取該類對應的 Class 對象
Class clazz=Person.class;
使用 Class 類中的 forName()靜態方法(最安全/性能最好)
Class clazz=Class.forName("類的全路徑"); (最經常使用)
當咱們得到了想要操做的類的 Class 對象後，能夠經過 Class 類中的方法獲取並查看該類中的方法
和屬性。

//獲取 Person 類的 Class 對象 Class clazz=Class.forName("reflection.Person");

//獲取 Person 類的全部方法信息 Method[] method=clazz.getDeclaredMethods(); for(Method m:method){ System.out.println(m.toString()); } //獲取 Person 類的全部成員屬性信息 Field[] field=clazz.getDeclaredFields(); for(Field f:field){ System.out.println(f.toString()); } //獲取 Person 類的全部構造方法信息 Constructor[] constructor=clazz.getDeclaredConstructors(); for(Constructor c:constructor){ System.out.println(c.toString()); }

5.1.2.7. 建立對象的兩種方法
Class 對象的 newInstance()
1. 使用 Class 對象的 newInstance()方法來建立該 Class 對象對應類的實例，可是這種方法要求
該 Class 對象對應的類有默認的空構造器。
調用 Constructor 對象的 newInstance()
2. 先使用 Class 對象獲取指定的 Constructor 對象，再調用 Constructor 對象的 newInstance()
方法來建立 Class 對象對應類的實例,經過這種方法能夠選定構造方法建立實例。

//獲取 Person 類的 Class 對象 Class clazz=Class.forName("reflection.Person"); //使用.newInstane 方法建立對象 Person p=(Person) clazz.newInstance(); //獲取構造方法並建立對象 Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class); //建立對象並設置屬性

Person p1=(Person) c.newInstance("李四","男",20);

 

5.1.3. JAVA 註解
5.1.3.1. 概念
Annotation（註解）是 Java 提供的一種對元程序中元素關聯信息和元數據（metadata）的途徑
和方法。 Annatation(註解)是一個接口，程序能夠經過反射來獲取指定程序中元素的 Annotation
對象，而後經過該 Annotation 對象來獲取註解中的元數據信息。
 

5.1.3.2. 4 種標準元註解
元註解的做用是負責註解其餘註解。 Java5.0 定義了 4 個標準的 meta-annotation 類型，它們被
用來提供對其它 annotation 類型做說明。
@Target 修飾的對象範圍
@Target說明了Annotation所修飾的對象範圍： Annotation可被用於 packages、 types（類、
接口、枚舉、 Annotation 類型）、類型成員（方法、構造方法、成員變量、枚舉值）、方法參數
和本地變量（如循環變量、 catch 參數） 。在 Annotation 類型的聲明中使用了 target 可更加明晰
其修飾的目標
 

@Retention 定義 被保留的時間長短
Retention 定義了該 Annotation 被保留的時間長短：表示須要在什麼級別保存註解信息，用於描
述註解的生命週期（即：被描述的註解在什麼範圍內有效），取值（RetentionPoicy）由：
 SOURCE:在源文件中有效（即源文件保留）
 CLASS:在 class 文件中有效（即 class 保留）
 RUNTIME:在運行時有效（即運行時保留）

 

@Documented 描述-javadoc
@ Documented 用於描述其它類型的 annotation 應該被做爲被標註的程序成員的公共 API，因
此能夠被例如 javadoc 此類的工具文檔化。
 

@Inherited 闡述了某個被標註的類型是被繼承的
@Inherited 元註解是一個標記註解， @Inherited 闡述了某個被標註的類型是被繼承的。若是一
個使用了@Inherited 修飾的 annotation 類型被用於一個 class，則這個 annotation 將被用於該
class 的子類。
 

5.1.3.3. 註解處理器
若是沒有用來讀取註解的方法和工做，那麼註解也就不會比註釋更有用處了。使用註解的過程當中，
很重要的一部分就是建立於使用註解處理器。 Java SE5 擴展了反射機制的 API，以幫助程序員快速
的構造自定義註解處理器。 下面實現一個註解處理器。
 

5.1.4. JAVA 內部類
Java 類中不只能夠定義變量和方法，還能夠定義類，這樣定義在類內部的類就被稱爲內部類。根
據定義的方式不一樣，內部類分爲靜態內部類，成員內部類，局部內部類，匿名內部類四種。
 

5.1.4.1. 靜態內部類
定義在類內部的靜態類，就是靜態內部類。

public class Out { private static int a; private int b; public static class Inner { public void print() { System.out.println(a); } } }

 

1. 靜態內部類能夠訪問外部類全部的靜態變量和方法，即便是 private 的也同樣。
2. 靜態內部類和通常類一致，能夠定義靜態變量、方法，構造方法等。
3. 其它類使用靜態內部類須要使用「外部類.靜態內部類」方式，以下所示： Out.Inner inner =
new Out.Inner();inner.print();
4. Java集合類HashMap內部就有一個靜態內部類Entry。 Entry是HashMap存放元素的抽象，
HashMap 內部維護 Entry 數組用了存放元素，可是 Entry 對使用者是透明的。像這種和外部
類關係密切的，且不依賴外部類實例的，均可以使用靜態內部類
 

5.1.4.2. 成員內部類

定義在類內部的非靜態類，就是成員內部類。成員內部類不能定義靜態方法和變量（final 修飾的
除外）。這是由於成員內部類是非靜態的， 類初始化的時候先初始化靜態成員，若是容許成員內
部類定義靜態變量，那麼成員內部類的靜態變量初始化順序是有歧義的。

public class Out { private static int a; private int b; public class Inner { public void print() { System.out.println(a); System.out.println(b); } } }

5.1.4.3. 局部內部類（定義在方法中的類）
定義在方法中的類，就是局部類。若是一個類只在某個方法中使用，則能夠考慮使用局部類。

public class Out { private static int a; private int b; public void test(final int c) { final int d = 1; class Inner { public void print() { System.out.println(c); } } } }

5.1.4.4. 匿名內部類（要繼承一個父類或者實現一個接口、直接使用
new 來生成一個對象的引用）
匿名內部類咱們必需要繼承一個父類或者實現一個接口，固然也僅能只繼承一個父類或者實現一
個接口。同時它也是沒有 class 關鍵字，這是由於匿名內部類是直接使用 new 來生成一個對象的引
用。

public abstract class Bird { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public abstract int fly(); } public class Test { public void test(Bird bird){ System.out.println(bird.getName() + "可以飛 " + bird.fly() + "米"); } public static void main(String[] args) { Test test = new Test(); test.test(new Bird() { public int fly() { return 10000; } public String getName() { return "大雁"; } }); } }

5.1.5. JAVA 泛型
泛型提供了編譯時類型安全檢測機制，該機制容許程序員在編譯時檢測到非法的類型。泛型的本
質是參數化類型，也就是說所操做的數據類型被指定爲一個參數。 好比咱們要寫一個排序方法，
可以對整型數組、字符串數組甚至其餘任何類型的數組進行排序，咱們就可使用 Java 泛型。
 

5.1.5.1. 泛型方法（<E>）
你能夠寫一個泛型方法，該方法在調用時能夠接收不一樣類型的參數。根據傳遞給泛型方法的參數
類型，編譯器適當地處理每個方法調用。

// 泛型方法 printArray public static < E > void printArray( E[] inputArray ) { for ( E element : inputArray ){ System.out.printf( "%s ", element ); } }

1. <? extends T>表示該通配符所表明的類型是 T 類型的子類。
2. <? super T>表示該通配符所表明的類型是 T 類型的父類

 

5.1.5.2. 泛型類<T>
泛型類的聲明和非泛型類的聲明相似，除了在類名後面添加了類型參數聲明部分。和泛型方法一
樣，泛型類的類型參數聲明部分也包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，
也被稱爲一個類型變量，是用於指定一個泛型類型名稱的標識符。由於他們接受一個或多個參數，
這些類被稱爲參數化的類或參數化的類型。

public class Box<T> { private T t; public void add(T t) { this.t = t; } public T get() { return t; }

 

5.1.5.3. 類型通配符?

類 型 通 配 符 一 般 是 使 用 ? 代 替 具 體 的 類 型 參 數 。 例 如 List<String>,List<Integer> 等全部 List<具體類型實參>的父類。

List<?> 在 邏 輯 上 是

5.1.5.4. 類型擦除
Java 中的泛型基本上都是在編譯器這個層次來實現的。在生成的 Java 字節代碼中是不包含泛
型中的類型信息的。使用泛型的時候加上的類型參數，會被編譯器在編譯的時候去掉。這個
過程就稱爲類型擦除。如在代碼中定義的 List<Object>和 List<String>等類型，在編譯以後
都會變成 List。 JVM 看到的只是 List，而由泛型附加的類型信息對 JVM 來講是不可見的。
類型擦除的基本過程也比較簡單，首先是找到用來替換類型參數的具體類。這個具體類通常
是 Object。若是指定了類型參數的上界的話，則使用這個上界。把代碼中的類型參數都替換
成具體的類。

5.1.6. JAVA 序列化(建立可複用的 Java 對象)
保存(持久化)對象及其狀態到內存或者磁盤
Java 平臺容許咱們在內存中建立可複用的 Java 對象，但通常狀況下，只有當 JVM 處於運行時，
這些對象纔可能存在，即，這些對象的生命週期不會比 JVM 的生命週期更長。 但在現實應用中，
就可能要求在JVM中止運行以後可以保存(持久化)指定的對象，並在未來從新讀取被保存的對象。
Java 對象序列化就可以幫助咱們實現該功能。
 

序列化對象以字節數組保持-靜態成員不保存
使用 Java 對象序列化， 在保存對象時，會把其狀態保存爲一組字節，在將來， 再將這些字節組裝
成對象。必須注意地是， 對象序列化保存的是對象的」狀態」，即它的成員變量。由此可知，對
象序列化不會關注類中的靜態變量。

 

序列化用戶遠程對象傳輸
除了在持久化對象時會用到對象序列化以外，當使用 RMI(遠程方法調用)，或在網絡中傳遞對象時，
都會用到對象序列化。 Java序列化API爲處理對象序列化提供了一個標準機制，該API簡單易用。
 

Serializable 實現序列化
在 Java 中， 只要一個類實現了 java.io.Serializable 接口，那麼它就能夠被序列化。
ObjectOutputStream 和 ObjectInputStream 對對象進行序列化及反序列化
經過 ObjectOutputStream 和 ObjectInputStream 對對象進行序列化及反序列化。
writeObject 和 readObject 自定義序列化策略
在類中增長 writeObject 和 readObject 方法能夠實現自定義序列化策略。
 

序列化 ID
虛擬機是否容許反序列化，不只取決於類路徑和功能代碼是否一致，一個很是重要的一點是兩個
類的序列化 ID 是否一致（就是 private static final long serialVersionUID）
 

序列化並不保存靜態變量
序列化子父類說明
要想將父類對象也序列化，就須要讓父類也實現 Serializable 接口。
 

Transient 關鍵字阻止該變量被序列化到文件中
1. 在變量聲明前加上 Transient 關鍵字，能夠阻止該變量被序列化到文件中，在被反序列
化後， transient 變量的值被設爲初始值，如 int 型的是 0，對象型的是 null。
2. 服務器端給客戶端發送序列化對象數據，對象中有一些數據是敏感的，好比密碼字符串
等，但願對該密碼字段在序列化時，進行加密，而客戶端若是擁有解密的密鑰，只有在
客戶端進行反序列化時，才能夠對密碼進行讀取，這樣能夠必定程度保證序列化對象的
數據安全
 

5.1.7. JAVA 複製
將一個對象的引用複製給另一個對象，一共有三種方式。第一種方式是直接賦值，第二種方式
是淺拷貝，第三種是深拷貝。因此你們知道了哈，這三種概念實際上都是爲了拷貝對象。

    5.1.7.1. 直接賦值複製
直接賦值。在 Java 中， A a1 = a2，咱們須要理解的是這實際上覆制的是引用，也就是
說 a1 和 a2 指向的是同一個對象。所以，當 a1 變化的時候， a2 裏面的成員變量也會跟
着變化。
5.1.7.2. 淺複製（複製引用但不復制引用的對象）
建立一個新對象，而後將當前對象的非靜態字段複製到該新對象， 若是字段是值類型的，
那麼對該字段執行復制；若是該字段是引用類型的話，則複製引用但不復制引用的對象。
所以，原始對象及其副本引用同一個對象。

class Resume implements Cloneable{ public Object clone() { try { return (Resume)super.clone(); } catch (Exception e) { e.printStackTrace(); return null; } } }

5.1.7.3. 深複製（複製對象和其應用對象）
深拷貝不只複製對象自己，並且複製對象包含的引用指向的全部對象。

class Student implements Cloneable { String name; int age; Professor p; Student(String name, int age, Professor p) { this.name = name; this.age = age; this.p = p; } public Object clone() { Student o = null; try { o = (Student) super.clone(); } catch (CloneNotSupportedException e) { System.out.println(e.toString()); } o.p = (Professor) p.clone(); return o; }

5.1.7.4. 序列化（深 clone 一中實現） 在 Java 語言裏深複製一個對象，經常能夠先使對象實現 Serializable 接口，而後把對 象（實際上只是對象的一個拷貝）寫到一個流裏，再從流裏讀出來，即可以重建對象。