Java初識

基礎概念

特色

• 徹底面向對象，動態
• 解釋性，簡單、易移植，跨平臺
• 安全健壯，高性能
• 多線程，分佈式

三種核心機制

• Java虛擬機 Java Virtual Machine
  
• 垃圾收集機制 Garbage collection
  
• 代碼安全性檢測 Code Security

注意，Java 語言是跨平臺（write once run anywhere）的，JVM 不是跨平臺的。Java 的跨平臺經過 JVM 實現。

三大平臺（技術架構）

• JavaSE：Java Platform，Standard Edition，基礎版
• JavaEE：Java Platform，Enterprise Edition，企業版
• JavaME：Java Platform，Micro Edition，主要用於移動設備

關於 JVM - JRE - JDK

• JVM ≈ 計算機系統（操做系統+硬件環境）
• JRE（Java Runtime Environment） = java虛擬機 + 核心類庫(輔助java虛擬機運行的文件)
• JDK （Java Development Kit）= jre + java開發工具

關於 Java.exe - Javac.exe

• Java.exe：java虛擬機解釋並執行指定的class文件 （java 指定的class文件）
• Javac.exe：java編譯器對指定的java源文件進行編譯 （javac java源文件）
• Javap.exe：Java反編譯器，javap -c -l -private 類名

關於 Java 的配置

• JAVA_HOME：
• PATH：
• CLASSPATH：

Java源文件結構

Java程序執行步驟： .java源文件，先編譯 -> .class(與平臺無關的字節碼文件) -> 後解釋，經過 JVM -> 特定平臺的機器碼 

  package packageName;
  import | import static packageName;
  public classDefinition | interfaceDefinition | EnumDefinition {}
  classDefinition | interfaceDefinition | EnumDefinition {}

注：一個源文件中只能有一個public類，不然編譯器找不到應該執行的main方法，可是一個源文件中能夠有多個非public類。一個源文件中也只能有一個public接口。一個源文件中也只能有一個public枚舉類。

關於訪問修飾符

垃圾回收

只負責在合適時間回收堆內存中處於不可達狀態的對象。強制（建議）進行垃圾回收方法：

• System.gc() / runFinalization()；
• Runtime.getRuntime.gc() / runFinalization()；

finalize：默認機制，Object 類的實例方法：  protected void finalize() throws Throwable  
虛引用：主要用於追蹤對象被垃圾回收的狀態。虛引用必須與引用隊列聯合使用 
JAR包 ：Java 檔案文件，Java Archive File。

• 壓縮，加快加載速度；
• 包封裝（工具類方法），安全，可移植；

注意事項

• 格式：jar cvf jar文件名 class文件或文件夾
• jar包打完後，要在清單文件中註明入口類（格式：Main-Class: 包名.類名）

 

Java類庫

[修飾符] class 類名
{
    初始化塊；成員變量；構造器；方法；內部類；
}

　[1]. Scanner 類
　　基於正則表達式的文本掃描器：輸入流、文件、字符串。
　[2]. System/Runtime 類　
　　與程序的運行平臺/運行時環境交互：環境變量、系統屬性以及文件加載、垃圾回收和資源清理。
　　System.identityHashCode(Object obj)：根據指定對象的地址精確計算到的hashCode值，identityHashCode值惟一標識對象。
　　Java 程序和 Runtime 實例一對一，getRuntime() 獲取。Runtime 類能夠單獨啓動一個進程運行操做系統的命令：rt.exec("命令")；
　[3]. String/Math 類
　[4]. Random/ThreadLocalRandom 類
　　減小多線程資源競爭，保證線程安全行性，靜態 current() 方法獲取 ThreadLocalRandom 對象。　　
　　Random rand = new Random(System.currentTimeMillis())；
　[5]. BigDecimal 類
　　解決 double 類型精度丟失問題、精確計算浮點數，建立方法：
　　·  基於 String 的構造器建立：new BigDecimal(String str)；
　　·  以 double 參數建立：BigDecimal.valueOf(double value)；
　[6]. Date/Calender 類
　　Date 類不推薦使用。Calender 類是抽象類，靜態方法 getInstance() 獲取 Calender 對象，Calender 支持較好的容錯性。注意，其 set() 方法有延遲修改的性質，能夠避免觸發屢次沒必要要的計算。　
　[7]. 其餘經常使用方法
　　·  MessageFormat：格式化字符串；
　　·  NumberFormat：格式化數字；
　　·  (Simple)DateFormat：格式化時間、日期；
　　 => DateTimeFormatter 格式器類：格式化日期時間、字符串解析；

繼承 Inheritance ~ 多態 Polymorphism ~ 組合

類單繼承，extends，Java類只能有一個直接父類。java.lang.Object類是全部類的父類。接口多實現，implements。
java.lang.Object

• Class<?> getClass()：返回對象的運行時類；
• protected object clone()：高效、(淺)複製獲得實例對象的副本；

class MyObj implements Cloneable {
    public MyObj clone(){
        return (MyObj)super.clone();
    }
}

Java規定：

• 若是兩個對象equals返回true，那麼這兩個對象的hashCode碼必須一致
• 在實際中，應該按需重寫 Object 類的 equals() 和 hashCode() 方法

Objects 工具類：空指針安全的
[1]. Objects.requireNonNull(obj)：對方法的形參做輸入校驗；　　 　
protected ~ final
protected：容許子類重寫父類方法，但不容許其餘類訪問，final是不容許子類重寫父類方法。
final：[1]. 變量不可變，方法不可重寫，類不能被繼承； [2]. 定義宏變量；
不可變類
該類的對象建立後，對象的實例變量不可變。注意，包含引用類型成員變量的不可變類須要提供保護措施。
[1]. private final 成員變量；
[2]. 帶參的構造器初始化[1]的成員變量，僅提供getter()方法；
this ~ super
this 是調用同一個類中重載的構造，super 是調用父類的構造器。
構造器 ~ 初始化塊
對Java對象執行指定的初始化操做。構造函數是給相應的對象初始化操做。

初始化塊在建立Java對象時隱式執行且在構造器以前。初始化塊沒有名字標識，修飾符只能爲static，靜態初始化塊先於普通初始化塊執行。

• 初始化塊，即構造代碼塊呢，是全部構造函數中的公共部分
• 給全部的對象統一的初始化

關於構造代碼塊和構造方法的關係（最好經過反編譯一個類來了解）

• 成員變量的聲明是在一個類的最前端
• 成員變量的初始化、構造代碼塊的代碼其實是在構造方法中執行的（反編譯能夠看出）
  • 構造代碼塊的代碼位於構造方法的代碼的前面執行
  • 成員變量的初始化和構造代碼塊的執行是按照二者在類中的前後位置
  • 構造方法的代碼其實是最後執行的

instanceof ~ (type)
objA instanceof classB，判斷引用類型對象objA是不是classB類或是其子類、實現類的實例。objA 的編譯時類型要麼是classB，要麼與classB有父子繼承關係，不然編譯錯誤。 在強制類型轉換(type)以前，先進行instanceof判斷，避免出現ClassCastException異常。相似 C# 中的 is 運算符。

if(objA instanceof classB)
    classB objB = (classB)objA;

組合 ~ 繼承
類的2種複用機制，組合是把舊類對象做爲新類的(private)成員變量進行整合用於實現新類的功能，繼承是(is-a)關係，組合是(has-a)關係；二者開銷僅差一個private成員變量。
abstract ~ final ~ static ~ private
abstract類只能被繼承，abstract方法必須由子類重寫。
 [1]. abstract不能與final同時修飾類或方法；
 [2]. abstract不能與static同時修飾方法，但能夠同時修飾內部類；
 [3]. abstract不能與private同時修飾方法；
接口 ~ 抽象類
抽象類：abstract，多個類的模板，模板模式；
接口：interface，多個類應遵照的公共行爲規範，面向接口耦合和通訊；
 [1]. 成員變量：靜態常量，默認 public static final ；
 [2]. 方法：抽象方法，默認 public abstract，同時Java8容許在接口裏定義默認方法(default)和類方法(static)，注意接口沒有構造方法
 [3]. 內部類，內部接口，內部枚舉，默認 public static；

多態

數據成員：父類和子類有相同的成員變量，多態下訪問的是父類的成員變量

• 當父類和子類具備相同的非靜態成員變量，多態下訪問的是父類的成員變量，編譯和運行參考左邊
• 當父類和子類具備相同的靜態成員變量，多態下訪問的是父類的靜態成員變量，編譯和運行參考左邊

成員方法

• 當父類和子類具備相同的非靜態方法（就是子類重寫父類方法），多態下訪問的是子類的成員方法（最經常使用的多態），編譯看左邊，運行看右邊
• 當父類和子類具備相同的靜態方法（就是子類重寫父類靜態方法），多態下訪問的是父類的靜態方法，編譯和運行參考左邊

內部類

優勢：成員內部類做爲外部類的成員，能夠訪問外部類的任何成員

場景：A類和B類，A類想直接訪問B類的成員，而B類又需創建A類的對象來訪問A類中的成員。這時，應該將A類定義成B類的內部類。

做用域

• 外部類：同一個包內(包訪問權限)和任何位置(公共訪問權限，public)
• 內部類：同一個類(private)、同一個包(包訪問權限)、父子類(protected)和任何位置(公共訪問權限，public)

相互訪問

• 內部類能夠直接訪問外部類的成員屬性
• 外部類須要建立內部類的對象才能訪問內部類的成員屬性
  • 外部類的成員函數訪問：Inner obj = new Inner()
  • 其餘類訪問：Outer.Inner obj = new Outer().new Inner() （如果靜態內部類，應爲 Outer.Inner obj = new Outer.Inner()）　

注意，內部類不能被外部類的子類重寫（類的限定名確定不一樣）。
非靜態內部類
實例相關，非靜態內部類對象裏保存外部類對象的引用，依存於外部類對象；非靜態內部類裏不能定義靜態成員（至於爲何，能夠考慮類的加載過程，並參考 http://bbs.csdn.net/topics/90510249）；
外部類訪問內部類：(new innerClass()).innerVar；
非靜態內部類的構造器必須經過外部類對象調用；非靜態內部類的子類的對象也依存於外部類對象；
靜態內部類
static，類相關，靜態內部類對象保存外部類的引用，依存於外部類；接口的內部類默認是 public static；
外部類訪問內部類：[1]. (new innerStaticClass()).innerVar；[2]. innerStaticClass.innerStaticVar；
靜態內部類的構造器經過外部類調用；　
匿名內部類
匿名內部類不能重複使用，必須繼承一個父類或實現一個接口。被匿名內部類訪問的局部變量默認是 final。最經常使用的建立匿名內部類的狀況是須要建立某個只有抽象方法的接口類型的對象。

注意，上面介紹的內部類都是成員內部類，還有一種特殊的內部類是定義在外部類的成員函數中，叫局部內部類，局部內部類只能訪問該成員函數的 final 屬性。

Lambda 表達式

Java8 引入 Lamba 表達式升級簡化匿名內部類、匿名方法，容許建立函數式接口的實例。Lambda 表達式的目標類型能且必須是明確的函數式接口，函數式接口只能聲明一個抽象方法。
[1]. 建立臨時對象； [2]. 賦值；

格式：（形參列表）->｛代碼塊/方法體｝  

方法引用 ~ 構造器引用
當方法體只有一條代碼時，能夠用方法引用和構造器引用替代 Lambda 表達式。

格式：類名::類方法/實例方法/new  

本質：利用簡潔的語法建立函數式接口的實例！ 關於匿名內部類和 Lamba 表達式的異同自行百度。

枚舉

枚舉類顯式繼承 java.lang.Enum 類，java.lang.Enum 類實現了 java.lang.Comparable 和 java.lang.Serializable 兩個接口。

• 非抽象枚舉類默認 final 修飾，即不能派生子類
• 枚舉類的構造器默認 private 修飾
• 枚舉類的實例默認 public static final 修飾 
• 枚舉類中聲明的每個枚舉值表明枚舉類的一個實例對象
• 聲明枚舉類時，也能夠聲明屬性、方法和構造函數
• 枚舉類能夠聲明抽象方法，可是要有具體的枚舉值去實現
• 枚舉類能夠實現接口(序列化)、繼承抽象類
• 若枚舉類只有一個枚舉值，能夠看成單例設計模式使用

1. public static <T extends Enum<T>> T valueOf(Class<T> enumType, string name)
靜態方法，用於返回指定枚舉類中指定名稱的枚舉值，以枚舉類 SeasonEnum 爲例：
  -- SeasonEnum se = Enum.valueOf(SeasonEnum.class, "SPRING" );
  -- SeasonEnum se = SeasonEnum.valueOf( "SPRING" );
2. 返回枚舉常量名稱、索引值
  -- SeasonEnum.SPRING;
  -- SeasonEnum.SPRING.name();
  -- SeasonEnum.SPRING.toString();
  -- SeasonEnum.SPRING.ordinal();  // 索引值　
3. 抽象枚舉類
枚舉類中利用 abstract 定義抽象方法，枚舉類默認修飾爲 abstract，同時每一個枚舉值必須顯式實現抽象方法。

Java 集合

Java 集合分爲 List、Set、Map、Queue 四種體系，接口 Collection 和 Map 是 Java 集合框架的根接口，List、 Set 和 Queue 接口派生於 Collection 接口。非類型安全，以 Object 類型存儲，須要強制類型轉換。　
Collection
 --  Iterator iterator()：用於遍歷集合元素；
 --  Object[] toArray()：集合轉化爲數組；
 --  void removeIf(Predicate filter)：批量刪除知足條件的元素，入參爲 Lambda 表達式；
 --  Stream stream(Predicate filter)：返回集合對象對應的 Stream 對象；（Stream 編程，利用 Stream 對象的彙集操做簡化對集合的操做），幾個流式 API：
 [I]. filter(Predicate predicate)：入參爲 Lambda 表達式，過濾 Stream 對象中不符合條件的元素；
 [II]. toArray()：將流 Stream 對象轉換爲數組；
 [III]. forEach(Consumer action)：入參爲 Lambda 表達式，遍歷流 Stream 對象中的元素；
　
List：有序、可重複
線性表接口，提供索引訪問、插入、刪除、替換。額外方法，入參都可爲 Lambda 表達式：

void sort(Comparator c)； 
void replaceAll(UnaryOperator operator)； 
ListIterator listIterator()； 

其中，ListIterator 接口繼承於 Iterator 接口，增長了前向迭代功能，專用於操做 List。 

[1]. ArrayList（使用頻率很是高） - Vector（線性安全的ArrayList）
List 接口的實現類，基於數組，默認長度10，每次擴容增加60%（1.5倍，(oldCapacity * 3)/2 + 1），封裝了一個容許動態再分配的 Object[] 數組。ArrayList 非線程安全（單線程效率高），Vector 線程安全（多線程安全，效率低），性能低於 ArrayList。繼承於 Vector 類的 Stack 子類也是線程安全的。推薦 Object get(int index) 隨機訪問元素。

[2]. LinkedList

類 LinkedList 既實現 List 接口，也實現 Deque 接口，基於鏈表。推薦 Iterator 迭代器隨機訪問元素。

Collection接口繼承接口Iterable，Collection體系都具有獲取自身迭代器的方法，只不過每一個子類集合都進行了重寫（由於數據結構不一樣）

ListIterator：List的特有迭代器，在迭代過程當中支持添加或修改元素。而其餘普通的迭代器，僅僅支持獲取和刪除操做。
小結：性能 ArrayList > LinkedList。

Queue：隊列集合
提供 offer() 和 poll() 入隊和出隊。
[1]. Deque -> ArrayDeque
接口 Deque 繼承於 Queue 接口，表明"雙端隊列"，能夠做爲"棧"使用。
Iterator descendingIterator()；逆向迭代雙端隊列 
類 ArrayDeque 既實現 Deque接口，也實現 List 接口，能夠做爲"棧"使用，基於數組。
[2]. PriorityQueue
優先級隊列，不容許 null 值。排序功能、元素非FIFO，排序方法參見 TreeSet。
Set：無序、不可重複
[1]. HashSet -> LinkedHashSet
HashSet 是 Set 接口的實現類，非線程安全。底層哈希表實現，按 Hash 算法 存儲元素（根據元素的 hashCode 值計算存儲位置並判重），元素值能夠爲null，存取和查找速度快。2 個 HashSet 元素相等的充要條件：

obj1.hashCode()==obj2.hashCode() && obj1.equals()==obj2.equals();  

元素的哈希值經過元素的hashcode方法獲取，首先判斷兩個元素的哈希值，若是哈希值同樣，接着會比較equals方法，若是equls爲true，視爲同一個元素，若是equals爲false就不是同一個元素（存儲位置：同一個hashCode位置上能夠存放多個元素。）。

注：爲保證 HashSet 功能的實現，hashCode() 和 equals() 方法是否重寫須要保持同步。
~> LinkedHashSet
HashSet 的子類。利用鏈表維護元素的插入順序，性能略低於 HashSet。
[2]. SortSet -> TreeSet
TreeSet 是 SortedSet 接口的實現類。按 紅黑樹 的數據結構有序存儲同類型元素：

• 天然排序：默認排序，元素類自己必須實現 Comparable 接口的 int compareTo(Object obj) 方法。
• 定製排序：容器類必須關聯 Comparator 接口的 int compare(Object o1, Object o2) 方法。

當元素自身不具有比較性，或者元素自身具有的比較性不是所需的，此時須要讓容器自身具有比較性。

定義一個類實現Comparator接口，實現compare方法，並將該接口的子類對象做爲參數傳遞給TreeSet集合的構造函數。

class MyComparator implements Comparator {
	public int compare(Object o1, Object o2) {

        }
}

當Comparable比較方式及Comparator比較方式同時存在，以Comparator比較方式爲主。

2 個 TreeSet 元素相等的充要條件：　

0 == this.compareTo(obj)  // 天然排序
0 == (Comparator對象 | Lambda表達式).compare(t1,t2)   // 定製排序

注：爲保證 TreeSet 功能的實現，天然排序中 compareTo() 和 equals() 方法須保持同步。
~> SortedSet
SortedSet 接口繼承自 Set 接口。
[3]. EnumSet
枚舉類型元素的有序集合類，以枚舉值在 Enum 類中的定義順序決定集合中元素的順序，元素不容許爲null。Enum 對象在內部以 位向量 的形式存儲，緊湊高效、佔用內存小、運行效率好。

EnumSet es = EnumSet.Allof/noneOf(Season.class);　　　  

小結：EnumSet 是全部 Set 實現類中性能最好的，性能 HashSet > TreeSet。HashSet、TreeSet、EnumSet 均線程不安全。

Map：映射集合
關係一對一， Map 的 key 值集合是 Set，value 集合是 List，Map 提供 Entry 內部類封裝 key-value對，經過 get(Object key)/remove(Object key) 獲取和刪除元素。
HashMap - Hashtable -> LinkedHashMap
HashMap 非線程安全、key和value 容許爲 null，Hashtable 線程同步安全，key和value 不容許爲 null，性能 HashMap > Hashtable。2 個 key 值相等的充要條件：

obj1.hashCode()==obj2.hashCode() && obj1.equals()==obj2.equals();  

2 個 value 相等的充要條件：

obj1.equals()==obj2.equals();

注：爲保證 HashMap-Hashtable 功能實現，hashCode()和equals()方法是否重寫需保持同步。
~> LinkedHashMap：
HashMap 的子類。利用雙向鏈表維護元素的插入順序，性能略低於 HashSMap。
~> Properties：
Hashtable 的子類，key和value 均爲 String 類型的 Map，store()和load() 存儲和加載 屬性文件。
SortedMap -> TreeMap
類 TreeMap 是 SortedMap 接口的實現類。按 紅黑樹 有序存儲同類型元素：參考 TreeSet。
EnumMap
內部以數組形式保存，緊湊高效，key 值不能爲 null，必須與枚舉類關聯。
小結：性能 HashMap > TreeMap，EnumMap 性能最好。
　
Iterator：迭代器，必須依附於 Collection 對象。
　- boolean hasNext()：
　- Object next()：
　- void remove()：用於刪除集合裏 next() 方法上一次返回的元素；
　- void forEachRemaining(Consumer action)：利用 Lambda 表達式遍歷集合元素；
注：Iterator 迭代器採用 fast-fail 快速失敗機制，迭代 Collection 集合時，集合元素不能被修改，不然當即拋出 ConcurrentModificationException 異常。

Collections：集合工具類，靜態方法
[1]. 排序、查找、替換等
　- void sort/reverse/swap/shuffle/retate(List list)： 排序/反轉/交換/隨機排序/旋轉
　- int binarySearch(List list, Object key)：二分查找
　- void fill(List list, Object obj)：元素填充
　- boolean replaceAll(List list, Object oldObj, Object newObj)：元素替換
[2]. 同步控制
提供 synchronizedXxx() 方法將指定集合包裝程線程同步的集合，解決多線程併發訪問集合時的線程安全問題。

Arrays：集合工具類，靜態方法

泛型 Generic

類型安全檢查，避免引發 ClassCastException 異常。以泛型List爲例，類型通配符 List<?> 能夠表示各類泛型List的父類，設定類型通配符的上限 List<? extends 父類> 限制其只表示某一類泛型List的父類，注意使用了類型通配符的集合不容許添加元素。通配符用於支持靈活的子類化。 

關於泛型，注意如下幾個問題：

• Java 不支持泛型數組
• 泛型類型必須是引用類型（泛型集合不能存儲基本數據類型，須使用基本數據類型的包裝類，int ---> Integer）

參考
[1]. 泛型知識點總結；
[2]. Java總結篇系列：Java泛型；

異常

Java 的異常機制主要依賴於 try，catch，finally，throw，throws 五個關鍵字。其中，finally 用於回收在 try 塊中打開的物理資源，throw 用於自行拋出異常的實例，throws 用於方法簽名中聲明該方法可能拋出異常、並由上一級調用者處理該異常。Java 的非正常狀況有 2 類：Error 和 Exception，均繼承於 Throwale 類。
Runtime 異常(運行時異常)，RuntimeException 類及其子類的實例，靈活易用。

Java的異常體系

全部的異常類均在 java.lang 包中。

其中，Throwable 描述錯誤和異常，Error（錯誤）表示不可治癒，Exception（異常）表示可治癒，異常包括運行時異常和非運行（編譯）時異常。

異常處理方式

• 在出現異常的方法中顯式捕獲異常並處理，方法的調用者不會捕獲到異常；
• 在方法簽名中用 throws 聲明拋出異常，異常捕獲以後交由調用者處理該異常；

優勢

• 正常業務代碼和異常處理代碼分離
• 程序容錯性，健壯、易維護；
• 提供多異常捕獲功能；

使用注意

• 異常處理結構 try 塊是必須的，catch 和 finally 塊可選但必須至少二選一；
• finally 塊總會執行，return 都不能中止 finally 的執行，除非 try 或 catch 塊中調用了 System.exit(1)； 退出虛擬機；
• 子類異常在前，父類異常在後，即先處理小異常，後處理大異常；

自定義異常 ：自定義異常類須要提供 2 個構造器。

 1 public class MyException extends Exception | RuntimeException
 2 {
 3     public MyException(){}
 4     public MyException(String msg){
 5         this.super(msg);
 6     }
 7     public MyException(Throwable t){  // 支持異常的鏈式處理
 8         this.super(t);
 9     }
10 }

異常鏈 ：鏈式處理
  捕獲 1 個異常後接着拋出另外一個異常，同時把原始異常的信息保存下來的機制。

圖形用戶界面編程 （瞭解便可）

　GUI（Graphic User Interface）編程，圖形界面組件庫（AWT + Swing）+ 事件處理機制。
 ·  AWT，抽象窗口工具集，Abstract Window Toolkit。 基本的窗口框架，重量級組件、依賴底層平臺；
 ·  Swing，輕量級組件，100% Java 實現，跨平臺性能好。採用 MVC 設計模式，實現 GUI 組件的顯示邏輯和數據邏輯的分離，靈活性好；

MySQL - JDBC

　關於 MySQL 的基礎，請參考 MySQL 初識 - sqh；
　關於 JDBC 的基礎，請參考 JDBC 初識 - sqh；

註解

　Annotation，接口，封裝元數據，修飾程序元素、提供爲其設置元數據的方法，容許在源文件中嵌入補充信息，相似 C# 中的特性。程序經過反射能獲取指定元素的 Annotation 對象、進而提取註解中的元數據。Java 8 支持重複註解，須要 @Repeatable 修飾。訪問和處理 Annotation 的工具爲 APT，Annotation Processing Tool，對源代碼文件進行檢測，執行嚴格的代碼檢查。
　- java.lang 包下的基本 Annotation：
  ·  @Override：限定子類必須重寫父類的方法，只能修飾方法；　
  ·  @Deprecated：標記已過期；
  ·  @Suppress Warnings：抑制編譯器警告；
  ·  @Safe Varargs：專用於抑制堆污染 Heap pollution 警告；
  ·  @FunctionalInterface：函數式接口聲明，要求接口只能包含一個抽象方法，只能修飾接口；
　- java.lang.annotation 包下的 元Annotation：
  ·  @Retention：指定 Annotation 的生命週期；
      RetentionPolicy.RUNTIME：　
      編譯器將 Annotation 記錄在 .class 文件中，運行時能夠經過 JVM 或反射獲取 Annotation 信息；
  ·  @Target：指定 Annotation 修飾的目標程序元素，全部程序元素的父接口爲 AnnotatedElement；
  ·  @Documented：指示被修飾的 Annotation 接口將被 javadoc 工具提取成文檔；
  ·  @Inherited：Annotation 具備父子繼承性；
  自定義 Annotation：默認繼承 Annotation 接口

 public @interface AnnotationName{...} 

  其中，Annotation 定義中，成員變量必須以無形參方法的形式定義，能夠用 default 指定初始值。
  AnnotatedElement 接口：用於提取 Annotation 信息，實例方法
 　 -  getAnnotation(xxx)：獲取程序元素上的指定註解；
 　 -  getAnnotations()： 獲取程序元素上的全部註解；
 　 -  isAnnotationPresent(xxx)()：判斷程序元素上是否存在指定註解；

I/O

   具體參考 Java 輸入輸出體系學習 - sqh；

多線程

   具體參考 Java 多線程學習 - sqh；

網絡編程　

   具體參考 Java 網絡編程學習 - sqh；

---

關於默認構造方法

• 若類沒有構造方法，java編譯器爲之添加默認構造方法，如有，不添加
• java編譯器爲類添加的默認構造方法的訪問權限與類的權限同樣

泛型通配符 ？

限定泛型通配符的邊界

• 上邊界：extends
• 下邊界：super 

? extends T：接收T類型或者T的子類型
? super T：接收T類型或者T的父類型

JDK5中的泛型容許在編寫集合代碼時，限制集合的處理類型，從而把原來程序運行時可能發生問題轉變爲編譯時問題，提升程序可讀性和穩定性。　　

關於數據類型間的強制類型轉換

一個數字，若沒有類型標識，默認是 int 類型

// 會進行強制類型轉換，若是超出類型能表示的範圍，會報錯，反之不會
byte b1 = 10;  // ok
byte b1 = 1000;  // 編譯失敗

byte b1 = 10;   byte b2 = 20;
byte b3 = 10 + 20;   // ok
byte b3 = b1 + b2;   // 編譯失敗

b2 = b1 + b2;   // 編譯失敗
b2 += b1;   // ok, Java 編譯器已經默認對 += 進行強制類型轉換

== 與 equals()

• ==：值相等（基本數據類型）、兩個引用是否指向同一(內存)對象（引用數據類型）；
• equals()：Object默認提供的equals()方法等效於 ==，實際中按需重寫；

直接量 「hello」 與 new String(「hello」)

• 「hello」 是編譯時常量，常量池管理之，在常量池中存在且惟一；
• new String(「hello」) 是運行時先用常量池管理 「hello」 直接量，再構造一個新的String對象存在堆中，實際上一共產生了2個 「hello」 字符串對象，返回值指向堆內存中的字符串對象；

構造器new 與 valueOf()

• new 構造器建立全新對象
• valueOf建立全新對象並緩存

後自增/減在JVM中的運行原理

int i = 0;
[1]. i++;    // i = 1
[2]. i = i++;   // i = 0

JVM會先聲明一個臨時變量保存自增/減以前的值，最後返回該值做爲表達式的值

第一步：int temp = i;   // temp = 0;
第二步：i++;   // i = i + 1;
第三步：return temp, 做爲表達式的值

注意，i 在該過程當中的變化：i = 0 ------> 1 ------> 0 

Static

靜態修飾符，其成員在方法區（數據共享區），優先於對象存在，做爲對象的共享數據。

• 靜態方法只能訪問靜態變量，也不能使用 this、super 關鍵字
• 靜態代碼塊優先於普通代碼塊優先於構造函數，用於對類初始化
• 靜態變量/方法/代碼塊隨着類的加載而加載，隨着類的消失而消失

關於實例變量和靜態變量

• 存放位置：類變量隨着類的加載而加載存在於方法（共享）區中，實例變量隨着對象的創建而存在於堆內存中
• 生命週期：類變量與類同在，實例變量與對象同在

 

Eclipse

關於快捷鍵

Alt + /：內容提示       Ctrl + 1：快速修復，編譯異常提示      Ctrl + shift + O：導包
Ctrl + /：單行註釋      Alt+上下鍵：代碼位置切換                Ctrl + Shift + F：格式化代碼塊
Ctrl+Shift+/或\：多行註釋    Ctrl+Shift+X/Y：大小寫轉換
查看源代碼：（1）Ctrl+單擊 須要查看源碼的類；（2）Ctrl+Shift+T