作者 | cxuan
來(lái)源 | 程序員cxuan
超長(zhǎng)預(yù)警??！全文4萬(wàn)多字，墻裂建議收藏！
先來(lái)看一下本篇文章的思維導(dǎo)圖吧，我會(huì)圍繞下面這些內(nèi)容進(jìn)行講解。內(nèi)容很干，小伙伴們看完還希望不吝轉(zhuǎn)發(fā)。
下面開(kāi)始我們的文章。
Java 概述
什么是 Java？
Java 是 Sun Microsystems 于1995 年首次發(fā)布的一種編程語(yǔ)言和計(jì)算平臺(tái)。編程語(yǔ)言還比較好理解，那么什么是 計(jì)算平臺(tái) 呢？
計(jì)算平臺(tái)是在電腦中運(yùn)行應(yīng)用程序（軟件）的環(huán)境，包括硬件環(huán)境和軟件環(huán)境。一般系統(tǒng)平臺(tái)包括一臺(tái)電腦的硬件體系結(jié)構(gòu)、操作系統(tǒng)、運(yùn)行時(shí)庫(kù)。
Java 是快速，安全和可靠的。從筆記本電腦到數(shù)據(jù)中心，從游戲機(jī)到科學(xué)超級(jí)計(jì)算機(jī)，從手機(jī)到互聯(lián)網(wǎng)，Java 無(wú)處不在！Java 主要分為三個(gè)版本
JavaSE(J2SE)(Java2 Platform Standard Edition，java平臺(tái)標(biāo)準(zhǔn)版）JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平臺(tái)企業(yè)版)JavaME(J2ME)(Java 2 Platform Micro Edition，java平臺(tái)微型版)。Java 的特點(diǎn)
Java 是一門面向?qū)ο蟮木幊陶Z(yǔ)言什么是面向?qū)ο?？面向?qū)ο?Object Oriented) 是一種軟件開(kāi)發(fā)思想。它是對(duì)現(xiàn)實(shí)世界的一種抽象，面向?qū)ο髸?huì)把相關(guān)的數(shù)據(jù)和方法組織為一個(gè)整體來(lái)看待。
相對(duì)的另外一種開(kāi)發(fā)思想就是面向過(guò)程的開(kāi)發(fā)思想，什么面向過(guò)程？面向過(guò)程(Procedure Oriented) 是一種以過(guò)程為中心的編程思想。舉個(gè)例子：比如你是個(gè)學(xué)生，你每天去上學(xué)需要做幾件事情？
起床、穿衣服、洗臉?biāo)⒀?，吃飯，去學(xué)校。一般是順序性的完成一系列動(dòng)作。
classstudent{voidstudent_wakeUp(){...}voidstudent_cloth(){...}voidstudent_wash(){...}voidstudent_eating(){...}voidstudent_gotoSchool(){...}}
而面向?qū)ο罂梢园褜W(xué)生進(jìn)行抽象，所以這個(gè)例子就會(huì)變?yōu)?/p>
classstudent(){voidwakeUp(){...}voidcloth(){...}voidwash(){...}voideating(){...}voidgotoSchool(){...}}
可以不用嚴(yán)格按照順序來(lái)執(zhí)行每個(gè)動(dòng)作。這是特點(diǎn)一。
Java 摒棄了 C++ 中難以理解的多繼承、指針、內(nèi)存管理等概念；不用手動(dòng)管理對(duì)象的生命周期，這是特征二。Java 語(yǔ)言具有功能強(qiáng)大和簡(jiǎn)單易用兩個(gè)特征，現(xiàn)在企業(yè)級(jí)開(kāi)發(fā)，快速敏捷開(kāi)發(fā)，尤其是各種框架的出現(xiàn)，使 Java 成為越來(lái)越火的一門語(yǔ)言。這是特點(diǎn)三。Java 是一門靜態(tài)語(yǔ)言，靜態(tài)語(yǔ)言指的就是在編譯期間就能夠知道數(shù)據(jù)類型的語(yǔ)言，在運(yùn)行前就能夠檢查類型的正確性，一旦類型確定后就不能再更改，比如下面這個(gè)例子。publicvoidfoo(){int x = 5;boolean b = x;}
靜態(tài)語(yǔ)言主要有 Pascal, Perl, C/C++, JAVA, C#, Scala 等。
相對(duì)應(yīng)的，動(dòng)態(tài)語(yǔ)言沒(méi)有任何特定的情況需要指定變量的類型，在運(yùn)行時(shí)確定的數(shù)據(jù)類型。比如有**Lisp, Perl, Python、Ruby、JavaScript **等。
從設(shè)計(jì)的角度上來(lái)說(shuō)，所有的語(yǔ)言都是設(shè)計(jì)用來(lái)把人類可讀的代碼轉(zhuǎn)換為機(jī)器指令。動(dòng)態(tài)語(yǔ)言是為了能夠讓程序員提高編碼效率，因此你可以使用更少的代碼來(lái)實(shí)現(xiàn)功能。靜態(tài)語(yǔ)言設(shè)計(jì)是用來(lái)讓硬件執(zhí)行的更高效，因此需要程序員編寫(xiě)準(zhǔn)確無(wú)誤的代碼，以此來(lái)讓你的代碼盡快的執(zhí)行。從這個(gè)角度來(lái)說(shuō)，靜態(tài)語(yǔ)言的執(zhí)行效率要比動(dòng)態(tài)語(yǔ)言高，速度更快。這是特點(diǎn)四。
Java 具有平臺(tái)獨(dú)立性和可移植性Java 有一句非常著名的口號(hào)：Write once, run anywhere，也就是一次編寫(xiě)、到處運(yùn)行。為什么 Java 能夠吹出這種牛批的口號(hào)來(lái)？核心就是 JVM。我們知道，計(jì)算機(jī)應(yīng)用程序和硬件之間會(huì)屏蔽很多細(xì)節(jié)，它們之間依靠操作系統(tǒng)完成調(diào)度和協(xié)調(diào)，大致的體系結(jié)構(gòu)如下
那么加上 Java 應(yīng)用、JVM 的體系結(jié)構(gòu)會(huì)變?yōu)槿缦?/p>
Java 是跨平臺(tái)的，已編譯的 Java 程序可以在任何帶有 JVM 的平臺(tái)上運(yùn)行。你可以在 Windows 平臺(tái)下編寫(xiě)代碼，然后拿到 Linux 平臺(tái)下運(yùn)行，該如何實(shí)現(xiàn)呢？
首先你需要在應(yīng)用中編寫(xiě) Java 代碼；
用 Eclipse 或者 javac 把 Java 代碼編譯為 .class 文件；
然后把你的 .class 文件打成 .jar 文件；
然后你的 .jar 文件就能夠在 Windows 、Mac OS X、Linux 系統(tǒng)下運(yùn)行了。不同的操作系統(tǒng)有不同的 JVM 實(shí)現(xiàn)，切換平臺(tái)時(shí)，不需要再次編譯你的 Java 代碼了。這是特點(diǎn)五。
Java 能夠容易實(shí)現(xiàn)多線程Java 是一門高級(jí)語(yǔ)言，高級(jí)語(yǔ)言會(huì)對(duì)用戶屏蔽很多底層實(shí)現(xiàn)細(xì)節(jié)。比如 Java 是如何實(shí)現(xiàn)多線程的。從操作系統(tǒng)的角度來(lái)說(shuō)，實(shí)現(xiàn)多線程的方式主要有下面這幾種
在用戶空間中實(shí)現(xiàn)多線程
在內(nèi)核空間中實(shí)現(xiàn)多線程
在用戶和內(nèi)核空間中混合實(shí)現(xiàn)線程
而我認(rèn)為 Java 應(yīng)該是在 用戶空間 實(shí)現(xiàn)的多線程，內(nèi)核是感知不到 Java 存在多線程機(jī)制的。這是特點(diǎn)六。
Java 具有高性能我們編寫(xiě)的代碼，經(jīng)過(guò) javac 編譯器編譯稱為 字節(jié)碼(bytecode)，經(jīng)過(guò) JVM 內(nèi)嵌的解釋器將字節(jié)碼轉(zhuǎn)換為機(jī)器代碼，這是解釋執(zhí)行，這種轉(zhuǎn)換過(guò)程效率較低。但是部分 JVM 的實(shí)現(xiàn)比如 Hotspot JVM 都提供了 JIT(Just-In-Time) 編譯器，也就是通常所說(shuō)的動(dòng)態(tài)編譯器，JIT 能夠在運(yùn)行時(shí)將熱點(diǎn)代碼編譯機(jī)器碼，這種方式運(yùn)行效率比較高，這是編譯執(zhí)行。所以 Java 不僅僅只是一種解釋執(zhí)行的語(yǔ)言。這是特點(diǎn)七。
Java 語(yǔ)言具有健壯性Java 的強(qiáng)類型機(jī)制、異常處理、垃圾的自動(dòng)收集等是 Java 程序健壯性的重要保證。這也是 Java 與 C 語(yǔ)言的重要區(qū)別。這是特點(diǎn)八。
Java 很容易開(kāi)發(fā)分布式項(xiàng)目Java 語(yǔ)言支持 Internet 應(yīng)用的開(kāi)發(fā)，Java 中有 net api，它提供了用于網(wǎng)絡(luò)應(yīng)用編程的類庫(kù)，包括URL、URLConnection、Socket、ServerSocket等。Java的 RMI（遠(yuǎn)程方法激活）機(jī)制也是開(kāi)發(fā)分布式應(yīng)用的重要手段。這是特點(diǎn)九。
Java 開(kāi)發(fā)環(huán)境
JDK
JDK（Java Development Kit）稱為 Java 開(kāi)發(fā)包或 Java 開(kāi)發(fā)工具，是一個(gè)編寫(xiě) Java 的 Applet 小程序和應(yīng)用程序的程序開(kāi)發(fā)環(huán)境。JDK是整個(gè)Java的核心，包括了Java運(yùn)行環(huán)境（Java Runtime Environment），一些Java 工具 和 Java 的核心類庫(kù)（Java API）。
我們可以認(rèn)真研究一下這張圖，它幾乎包括了 Java 中所有的概念，我使用的是 jdk1.8，可以點(diǎn)進(jìn)去 Description of Java Conceptual Diagram， 可以發(fā)現(xiàn)這里面包括了所有關(guān)于 Java 的描述
Oracle 提供了兩種 Java 平臺(tái)的實(shí)現(xiàn)，一種是我們上面說(shuō)的 JDK，Java 開(kāi)發(fā)標(biāo)準(zhǔn)工具包，一種是 JRE，叫做Java Runtime Environment，Java 運(yùn)行時(shí)環(huán)境。JDK 的功能要比 JRE 全很多。
JRE
JRE 是個(gè)運(yùn)行環(huán)境，JDK 是個(gè)開(kāi)發(fā)環(huán)境。因此寫(xiě) Java 程序的時(shí)候需要 JDK，而運(yùn)行 Java 程序的時(shí)候就需要JRE。而 JDK 里面已經(jīng)包含了JRE，因此只要安裝了JDK，就可以編輯 Java 程序，也可以正常運(yùn)行 Java 程序。但由于 JDK 包含了許多與運(yùn)行無(wú)關(guān)的內(nèi)容，占用的空間較大，因此運(yùn)行普通的 Java 程序無(wú)須安裝 JDK，而只需要安裝 JRE 即可。
Java 開(kāi)發(fā)環(huán)境配置
這個(gè)地方不再多說(shuō)了，網(wǎng)上有很多教程配置的資料可供參考。
Java 基本語(yǔ)法
在配置完 Java 開(kāi)發(fā)環(huán)境，并下載 Java 開(kāi)發(fā)工具（Eclipse、IDEA 等）后，就可以寫(xiě) Java 代碼了，因?yàn)楸酒恼率菑念^梳理 Java 體系，所以有必要從基礎(chǔ)的概念開(kāi)始談起。
數(shù)據(jù)類型
在 Java 中，數(shù)據(jù)類型只有四類八種
整數(shù)型：byte、short、int、longbyte 也就是字節(jié)，1 byte = 8 bits，byte 的默認(rèn)值是 0 ；
short 占用兩個(gè)字節(jié)，也就是 16 位，1 short = 16 bits，它的默認(rèn)值也是 0 ；
int 占用四個(gè)字節(jié)，也就是 32 位，1 int = 32 bits，默認(rèn)值是 0 ；
long 占用八個(gè)字節(jié)，也就是 64 位，1 long = 64 bits，默認(rèn)值是 0L；
所以整數(shù)型的占用字節(jié)大小空間為 long > int > short > byte
浮點(diǎn)型浮點(diǎn)型有兩種數(shù)據(jù)類型：float 和 double
float 是單精度浮點(diǎn)型，占用 4 位，1 float = 32 bits，默認(rèn)值是 0.0f；
double 是雙精度浮點(diǎn)型，占用 8 位，1 double = 64 bits，默認(rèn)值是 0.0d；
字符型字符型就是 char，char 類型是一個(gè)單一的 16 位 Unicode 字符，最小值是 \u0000 (也就是 0 )，最大值是 \uffff (即為 65535)，char 數(shù)據(jù)類型可以存儲(chǔ)任何字符，例如 char a = 'A'。
布爾型布爾型指的就是 boolean，boolean 只有兩種值，true 或者是 false，只表示 1 位，默認(rèn)值是 false。
以上 x 位都指的是在內(nèi)存中的占用。
基礎(chǔ)語(yǔ)法
大小寫(xiě)敏感：Java 是對(duì)大小寫(xiě)敏感的語(yǔ)言，例如 Hello 與 hello 是不同的，這其實(shí)就是 Java 的字符串表示方式類名：對(duì)于所有的類來(lái)說(shuō)，首字母應(yīng)該大寫(xiě)，例如 MyFirstClass包名：包名應(yīng)該盡量保證小寫(xiě)，例如 my.first.package方法名：方法名首字母需要小寫(xiě)，后面每個(gè)單詞字母都需要大寫(xiě)，例如 myFirstMethod()運(yùn)算符
運(yùn)算符不只 Java 中有，其他語(yǔ)言也有運(yùn)算符，運(yùn)算符是一些特殊的符號(hào)，主要用于數(shù)學(xué)函數(shù)、一些類型的賦值語(yǔ)句和邏輯比較方面，我們就以 Java 為例，來(lái)看一下運(yùn)算符。
賦值運(yùn)算符賦值運(yùn)算符使用操作符 = 來(lái)表示，它的意思是把 = 號(hào)右邊的值復(fù)制給左邊，右邊的值可以是任何常數(shù)、變量或者表達(dá)式，但左邊的值必須是一個(gè)明確的，已經(jīng)定義的變量。比如 int a = 4。
但是對(duì)于對(duì)象來(lái)說(shuō)，復(fù)制的不是對(duì)象的值，而是對(duì)象的引用，所以如果說(shuō)將一個(gè)對(duì)象復(fù)制給另一個(gè)對(duì)象，實(shí)際上是將一個(gè)對(duì)象的引用賦值給另一個(gè)對(duì)象。
算數(shù)運(yùn)算符算數(shù)運(yùn)算符就和數(shù)學(xué)中的數(shù)值計(jì)算差不多，主要有
算數(shù)運(yùn)算符需要注意的就是優(yōu)先級(jí)問(wèn)題，當(dāng)一個(gè)表達(dá)式中存在多個(gè)操作符時(shí)，操作符的優(yōu)先級(jí)順序就決定了計(jì)算順序，最簡(jiǎn)單的規(guī)則就是先乘除后加減，() 的優(yōu)先級(jí)最高，沒(méi)必要記住所有的優(yōu)先級(jí)順序，不確定的直接用 () 就可以了。
自增、自減運(yùn)算符這個(gè)就不文字解釋了，解釋不如直接看例子明白
int a = 5;b = ++a;c = a++;
比較運(yùn)算符比較運(yùn)算符用于程序中的變量之間，變量和自變量之間以及其他類型的信息之間的比較。
比較運(yùn)算符的運(yùn)算結(jié)果是 boolean 型。當(dāng)運(yùn)算符對(duì)應(yīng)的關(guān)系成立時(shí)，運(yùn)算的結(jié)果為 true，否則為 false。比較運(yùn)算符共有 6 個(gè)，通常作為判斷的依據(jù)用于條件語(yǔ)句中。
邏輯運(yùn)算符邏輯運(yùn)算符主要有三種，與、或、非
下面是邏輯運(yùn)算符對(duì)應(yīng)的 true/false 符號(hào)表
按位運(yùn)算符按位運(yùn)算符用來(lái)操作整數(shù)基本類型中的每個(gè)比特位，也就是二進(jìn)制位。按位操作符會(huì)對(duì)兩個(gè)參數(shù)中對(duì)應(yīng)的位執(zhí)行布爾代數(shù)運(yùn)算，并最終生成一個(gè)結(jié)果。
如果進(jìn)行比較的雙方是數(shù)字的話，那么進(jìn)行比較就會(huì)變?yōu)榘次贿\(yùn)算。
按位與：按位進(jìn)行與運(yùn)算（AND），兩個(gè)操作數(shù)中位都為1，結(jié)果才為1，否則結(jié)果為0。需要首先把比較雙方轉(zhuǎn)換成二進(jìn)制再按每個(gè)位進(jìn)行比較
按位或：按位進(jìn)行或運(yùn)算（OR），兩個(gè)位只要有一個(gè)為1，那么結(jié)果就是1，否則就為0。
按位非：按位進(jìn)行異或運(yùn)算（XOR），如果位為0，結(jié)果是1，如果位為1，結(jié)果是0。
按位異或：按位進(jìn)行取反運(yùn)算（NOT），兩個(gè)操作數(shù)的位中，相同則結(jié)果為0，不同則結(jié)果為1。
移位運(yùn)算符移位運(yùn)算符用來(lái)將操作數(shù)向某個(gè)方向（向左或者右）移動(dòng)指定的二進(jìn)制位數(shù)。
三元運(yùn)算符三元運(yùn)算符是類似 if...else... 這種的操作符，語(yǔ)法為：條件表達(dá)式？表達(dá)式 1：表達(dá)式 2。問(wèn)號(hào)前面的位置是判斷的條件，判斷結(jié)果為布爾型，為 true 時(shí)調(diào)用表達(dá)式 1，為 false 時(shí)調(diào)用表達(dá)式 2。
Java 執(zhí)行控制流程
Java 中的控制流程其實(shí)和 C 一樣，在 Java 中，流程控制會(huì)涉及到包括 if-else、while、do-while、for、return、break 以及選擇語(yǔ)句 switch。下面以此進(jìn)行分析
條件語(yǔ)句
條件語(yǔ)句可根據(jù)不同的條件執(zhí)行不同的語(yǔ)句。包括 if 條件語(yǔ)句與 switch 多分支語(yǔ)句。
if 條件語(yǔ)句
if 語(yǔ)句可以單獨(dú)判斷表達(dá)式的結(jié)果，表示表達(dá)的執(zhí)行結(jié)果，例如
int a = 10;if(a > 10){returntrue;}returnfalse;
if...else 條件語(yǔ)句
if 語(yǔ)句還可以與 else 連用，通常表現(xiàn)為 如果滿足某種條件，就進(jìn)行某種處理，否則就進(jìn)行另一種處理。
int a = 10;int b = 11;if(a >= b){ System.out.println("a >= b");}else{ System.out.println("a < b");}
if 后的 () 內(nèi)的表達(dá)式必須是 boolean 型的。如果為 true，則執(zhí)行 if 后的復(fù)合語(yǔ)句；如果為 false，則執(zhí)行 else 后的復(fù)合語(yǔ)句。
if...else if 多分支語(yǔ)句
上面中的 if...else 是單分支和兩個(gè)分支的判斷，如果有多個(gè)判斷條件，就需要使用 if...else if
int x = 40;if(x > 60) { System.out.println("x的值大于60");} elseif (x > 30) { System.out.println("x的值大于30但小于60");} elseif (x > 0) { System.out.println("x的值大于0但小于30");} else { System.out.println("x的值小于等于0");}
switch 多分支語(yǔ)句
一種比 **if...else if ** 語(yǔ)句更優(yōu)雅的方式是使用 switch 多分支語(yǔ)句，它的示例如下
switch (week) {case1: System.out.println("Monday");break;case2: System.out.println("Tuesday");break;case3: System.out.println("Wednesday");break;case4: System.out.println("Thursday");break;case5: System.out.println("Friday");break;case6: System.out.println("Saturday");break;case7: System.out.println("Sunday");break;default: System.out.println("No Else");break;}
循環(huán)語(yǔ)句
循環(huán)語(yǔ)句就是在滿足一定的條件下反復(fù)執(zhí)行某一表達(dá)式的操作，直到滿足循環(huán)語(yǔ)句的要求。使用的循環(huán)語(yǔ)句主要有 **for、do...while() 、 while **，
while 循環(huán)語(yǔ)句
while 循環(huán)語(yǔ)句的循環(huán)方式為利用一個(gè)條件來(lái)控制是否要繼續(xù)反復(fù)執(zhí)行這個(gè)語(yǔ)句。while 循環(huán)語(yǔ)句的格式如下
while(布爾值){ 表達(dá)式}
它的含義是，當(dāng) (布爾值) 為 true 的時(shí)候，執(zhí)行下面的表達(dá)式，布爾值為 false 的時(shí)候，結(jié)束循環(huán)，布爾值其實(shí)也是一個(gè)表達(dá)式，比如
int a = 10;while(a > 5){ a--;}
do...while 循環(huán)
while 與 do...while 循環(huán)的唯一區(qū)別是 do...while 語(yǔ)句至少執(zhí)行一次，即使第一次的表達(dá)式為 false。而在 while 循環(huán)中，如果第一次條件為 false，那么其中的語(yǔ)句根本不會(huì)執(zhí)行。在實(shí)際應(yīng)用中，while 要比 do...while 應(yīng)用的更廣。它的一般形式如下
int b = 10;// do···while循環(huán)語(yǔ)句do { System.out.println("b == " + b); b--;} while(b == 1);
for 循環(huán)語(yǔ)句
for 循環(huán)是我們經(jīng)常使用的循環(huán)方式，這種形式會(huì)在第一次迭代前進(jìn)行初始化。它的形式如下
for(初始化; 布爾表達(dá)式; 步進(jìn)){}
每次迭代前會(huì)測(cè)試布爾表達(dá)式。如果獲得的結(jié)果是 false，就會(huì)執(zhí)行 for 語(yǔ)句后面的代碼；每次循環(huán)結(jié)束，會(huì)按照步進(jìn)的值執(zhí)行下一次循環(huán)。
逗號(hào)操作符
這里不可忽略的一個(gè)就是逗號(hào)操作符，Java 里唯一用到逗號(hào)操作符的就是 for 循環(huán)控制語(yǔ)句。在表達(dá)式的初始化部分，可以使用一系列的逗號(hào)分隔的語(yǔ)句；通過(guò)逗號(hào)操作符，可以在 for 語(yǔ)句內(nèi)定義多個(gè)變量，但它們必須具有相同的類型
for(int i = 1;j = i + 10;i < 5;i++, j = j * 2){}
for-each 語(yǔ)句
在 Java JDK 1.5 中還引入了一種更加簡(jiǎn)潔的、方便對(duì)數(shù)組和集合進(jìn)行遍歷的方法，即 for-each 語(yǔ)句，例子如下
int array[] = {7, 8, 9};for (int arr : array) { System.out.println(arr);}
跳轉(zhuǎn)語(yǔ)句
Java 語(yǔ)言中，有三種跳轉(zhuǎn)語(yǔ)句: break、continue 和 return
break 語(yǔ)句
break 語(yǔ)句我們?cè)?switch 中已經(jīng)見(jiàn)到了，它是用于終止循環(huán)的操作，實(shí)際上 break 語(yǔ)句在for、while、do···while循環(huán)語(yǔ)句中，用于強(qiáng)行退出當(dāng)前循環(huán)，例如
for(int i = 0;i < 10;i++){if(i == 5){break; }}
continue 語(yǔ)句
continue 也可以放在循環(huán)語(yǔ)句中，它與 break 語(yǔ)句具有相反的效果，它的作用是用于執(zhí)行下一次循環(huán)，而不是退出當(dāng)前循環(huán)，還以上面的例子為主
for(int i = 0;i < 10;i++){ System.out.printl(" i = " + i );if(i == 5){ System.out.printl("continue ... ");continue; }}
return 語(yǔ)句
return 語(yǔ)句可以從一個(gè)方法返回，并把控制權(quán)交給調(diào)用它的語(yǔ)句。
publicvoidgetName(){return name;}
面向?qū)ο?/p>
下面我們來(lái)探討面向?qū)ο蟮乃枷耄嫦驅(qū)ο蟮乃枷胍呀?jīng)逐步取代了過(guò)程化的思想 --- 面向過(guò)程，Java 是面向?qū)ο蟮母呒?jí)編程語(yǔ)言，面向?qū)ο笳Z(yǔ)言具有如下特征
面向?qū)ο笫且环N常見(jiàn)的思想，比較符合人們的思考習(xí)慣；面向?qū)ο罂梢詫?fù)雜的業(yè)務(wù)邏輯簡(jiǎn)單化，增強(qiáng)代碼復(fù)用性；面向?qū)ο缶哂谐橄蟆⒎庋b、繼承、多態(tài)等特性。面向?qū)ο蟮木幊陶Z(yǔ)言主要有：C++、Java、C#等。
所以必須熟悉面向?qū)ο蟮乃枷氩拍芫帉?xiě)出 Java 程序。
類也是一種對(duì)象
現(xiàn)在我們來(lái)認(rèn)識(shí)一個(gè)面向?qū)ο蟮男碌母拍?--- 類，什么是類，它就相當(dāng)于是一系列對(duì)象的抽象，就比如書(shū)籍一樣，類相當(dāng)于是書(shū)的封面，大多數(shù)面向?qū)ο蟮恼Z(yǔ)言都使用 class 來(lái)定義類，它告訴你它里面定義的對(duì)象都是什么樣的，我們一般使用下面來(lái)定義類
classClassName{// body;}
代碼段中涉及一個(gè)新的概念 // ，這個(gè)我們后面會(huì)說(shuō)。上面，你聲明了一個(gè) class 類，現(xiàn)在，你就可以使用 new 來(lái)創(chuàng)建這個(gè)對(duì)象
ClassName classname = new ClassName();
一般，類的命名遵循駝峰原則，它的定義如下
駱駝式命名法（Camel-Case）又稱駝峰式命名法，是電腦程式編寫(xiě)時(shí)的一套命名規(guī)則（慣例）。正如它的名稱 CamelCase 所表示的那樣，是指混合使用大小寫(xiě)字母來(lái)構(gòu)成變量和函數(shù)的名字。程序員們?yōu)榱俗约旱拇a能更容易的在同行之間交流，所以多采取統(tǒng)一的可讀性比較好的命名方式。
對(duì)象的創(chuàng)建
在 Java 中，萬(wàn)事萬(wàn)物都是對(duì)象。這句話相信你一定不陌生，盡管一切都看作是對(duì)象，但是你操縱的卻是一個(gè)對(duì)象的 引用(reference)。在這里有一個(gè)很形象的比喻：你可以把車鑰匙和車看作是一組對(duì)象引用和對(duì)象的組合。當(dāng)你想要開(kāi)車的時(shí)候，你首先需要拿出車鑰匙點(diǎn)擊開(kāi)鎖的選項(xiàng)，停車時(shí)，你需要點(diǎn)擊加鎖來(lái)鎖車。車鑰匙相當(dāng)于就是引用，車就是對(duì)象，由車鑰匙來(lái)驅(qū)動(dòng)車的加鎖和開(kāi)鎖。并且，即使沒(méi)有車的存在，車鑰匙也是一個(gè)獨(dú)立存在的實(shí)體，也就是說(shuō)，你有一個(gè)對(duì)象引用，但你不一定需要一個(gè)對(duì)象與之關(guān)聯(lián)，也就是
Car carKey;
這里創(chuàng)建的只是引用，而并非對(duì)象，但是如果你想要使用 s 這個(gè)引用時(shí)，會(huì)返回一個(gè)異常，告訴你需要一個(gè)對(duì)象來(lái)和這個(gè)引用進(jìn)行關(guān)聯(lián)。一種安全的做法是，在創(chuàng)建對(duì)象引用時(shí)同時(shí)把一個(gè)對(duì)象賦給它。
Car carKey = new Car();
在 Java 中，一旦創(chuàng)建了一個(gè)引用，就希望它能與一個(gè)新的對(duì)象進(jìn)行關(guān)聯(lián)，通常使用 new 操作符來(lái)實(shí)現(xiàn)這一目的。new 的意思是，給我一個(gè)新對(duì)象，如果你不想相親，自己 new 一個(gè)對(duì)象就好了。祝你下輩子幸福。
屬性和方法
類一個(gè)最基本的要素就是有屬性和方法。
屬性也被稱為字段，它是類的重要組成部分，屬性可以是任意類型的對(duì)象，也可以是基本數(shù)據(jù)類型。例如下
classA{int a; Apple apple;}
類中還應(yīng)該包括方法，方法表示的是 做某些事情的方式。方法其實(shí)就是函數(shù)，只不過(guò) Java 習(xí)慣把函數(shù)稱為方法。這種叫法也體現(xiàn)了面向?qū)ο蟮母拍睢?/p>
方法的基本組成包括 方法名稱、參數(shù)、返回值和方法體， 下面是它的示例
publicintgetResult(){// ...return1;}
其中，getResult 就是方法名稱、() 里面表示方法接收的參數(shù)、return 表示方法的返回值，注意：方法的返回值必須和方法的參數(shù)類型保持一致。有一種特殊的參數(shù)類型 --- void 表示方法無(wú)返回值。{} 包含的代碼段被稱為方法體。
構(gòu)造方法
在 Java 中，有一種特殊的方法被稱為 構(gòu)造方法，也被稱為構(gòu)造函數(shù)、構(gòu)造器等。在 Java 中，通過(guò)提供這個(gè)構(gòu)造器，來(lái)確保每個(gè)對(duì)象都被初始化。構(gòu)造方法只能在對(duì)象的創(chuàng)建時(shí)期調(diào)用一次，保證了對(duì)象初始化的進(jìn)行。構(gòu)造方法比較特殊，它沒(méi)有參數(shù)類型和返回值，它的名稱要和類名保持一致，并且構(gòu)造方法可以有多個(gè)，下面是一個(gè)構(gòu)造方法的示例
classApple{int sum; String color;publicApple(){}publicApple(int sum){}publicApple(String color){}publicApple(int sum,String color){}}
上面定義了一個(gè) Apple 類，你會(huì)發(fā)現(xiàn)這個(gè) Apple 類沒(méi)有參數(shù)類型和返回值，并且有多個(gè)以 Apple 同名的方法，而且各個(gè) Apple 的參數(shù)列表都不一樣，這其實(shí)是一種多態(tài)的體現(xiàn)，我們后面會(huì)說(shuō)。在定義完成構(gòu)造方法后，我們就能夠創(chuàng)建 Apple 對(duì)象了。
classcreateApple{publicstaticvoidmain(String[] args){ Apple apple1 = new Apple(); Apple apple2 = new Apple(1); Apple apple3 = new Apple("red"); Apple apple4 = new Apple(2,"color"); }}
如上面所示，我們定義了四個(gè) Apple 對(duì)象，并調(diào)用了 Apple 的四種不同的構(gòu)造方法，其中，不加任何參數(shù)的構(gòu)造方法被稱為默認(rèn)的構(gòu)造方法，也就是
Apple apple1 = new Apple();
如果類中沒(méi)有定義任何構(gòu)造方法，那么 JVM 會(huì)為你自動(dòng)生成一個(gè)構(gòu)造方法，如下
classApple{int sum; String color;}classcreateApple{publicstaticvoidmain(String[] args){ Apple apple1 = new Apple(); }}
上面代碼不會(huì)發(fā)生編譯錯(cuò)誤，因?yàn)?Apple 對(duì)象包含了一個(gè)默認(rèn)的構(gòu)造方法。
默認(rèn)的構(gòu)造方法也被稱為默認(rèn)構(gòu)造器或者無(wú)參構(gòu)造器。
這里需要注意一點(diǎn)的是，即使 JVM 會(huì)為你默認(rèn)添加一個(gè)無(wú)參的構(gòu)造器，但是如果你手動(dòng)定義了任何一個(gè)構(gòu)造方法，JVM 就不再為你提供默認(rèn)的構(gòu)造器，你必須手動(dòng)指定，否則會(huì)出現(xiàn)編譯錯(cuò)誤。
顯示的錯(cuò)誤是，必須提供 Apple 帶有 int 參數(shù)的構(gòu)造函數(shù)，而默認(rèn)的無(wú)參構(gòu)造函數(shù)沒(méi)有被允許使用。
方法重載
在 Java 中一個(gè)很重要的概念是方法的重載，它是類名的不同表現(xiàn)形式。我們上面說(shuō)到了構(gòu)造函數(shù)，其實(shí)構(gòu)造函數(shù)也是重載的一種。另外一種就是方法的重載
publicclassApple{int sum; String color;publicApple(){}publicApple(int sum){}publicintgetApple(int num){return1; }public String getApple(String color){return"color"; }}
如上面所示，就有兩種重載的方式，一種是 Apple 構(gòu)造函數(shù)的重載，一種是 getApple 方法的重載。
但是這樣就涉及到一個(gè)問(wèn)題，要是有幾個(gè)相同的名字，Java 如何知道你調(diào)用的是哪個(gè)方法呢？這里記住一點(diǎn)即可，每個(gè)重載的方法都有獨(dú)一無(wú)二的參數(shù)列表。其中包括參數(shù)的類型、順序、參數(shù)數(shù)量等，滿足一種一個(gè)因素就構(gòu)成了重載的必要條件。
請(qǐng)記住下面重載的條件
方法名稱必須相同。參數(shù)列表必須不同（個(gè)數(shù)不同、或類型不同、參數(shù)類型排列順序不同等）。方法的返回類型可以相同也可以不相同。僅僅返回類型不同不足以成為方法的重載。重載是發(fā)生在編譯時(shí)的，因?yàn)榫幾g器可以根據(jù)參數(shù)的類型來(lái)選擇使用哪個(gè)方法。方法的重寫(xiě)
方法的重寫(xiě)與重載雖然名字很相似，但卻完全是不同的東西。方法重寫(xiě)的描述是對(duì)子類和父類之間的。而重載指的是同一類中的。例如如下代碼
classFruit{publicvoideat(){ System.out.printl('eat fruit'); }}classAppleextendsFruit{@Overridepublicvoideat(){ System.out.printl('eat apple'); }}
上面這段代碼描述的就是重寫(xiě)的代碼，你可以看到，子類 Apple 中的方法和父類 Fruit 中的方法同名，所以，我們能夠推斷出重寫(xiě)的原則
重寫(xiě)的方法必須要和父類保持一致，包括返回值類型,方法名,參數(shù)列表也都一樣。重寫(xiě)的方法可以使用 @Override 注解來(lái)標(biāo)識(shí)子類中重寫(xiě)方法的訪問(wèn)權(quán)限不能低于父類中方法的訪問(wèn)權(quán)限。初始化
類的初始化
上面我們創(chuàng)建出來(lái)了一個(gè) Car 這個(gè)對(duì)象，其實(shí)在使用 new 關(guān)鍵字創(chuàng)建一個(gè)對(duì)象的時(shí)候，其實(shí)是調(diào)用了這個(gè)對(duì)象無(wú)參數(shù)的構(gòu)造方法進(jìn)行的初始化，也就是如下這段代碼
classCar{publicCar(){}}
這個(gè)無(wú)參數(shù)的構(gòu)造函數(shù)可以隱藏，由 JVM 自動(dòng)添加。也就是說(shuō)，構(gòu)造函數(shù)能夠確保類的初始化。
成員初始化
Java 會(huì)盡量保證每個(gè)變量在使用前都會(huì)獲得初始化，初始化涉及兩種初始化。
一種是編譯器默認(rèn)指定的字段初始化，基本數(shù)據(jù)類型的初始化
一種是其他對(duì)象類型的初始化，String 也是一種對(duì)象，對(duì)象的初始值都為 null ，其中也包括基本類型的包裝類。一種是指定數(shù)值的初始化，例如int a = 11
也就是說(shuō)， 指定 a 的初始化值不是 0 ，而是 11。其他基本類型和對(duì)象類型也是一樣的。
構(gòu)造器初始化
可以利用構(gòu)造器來(lái)對(duì)某些方法和某些動(dòng)作進(jìn)行初始化，確定初始值，例如
publicclassCounter{int i;publicCounter(){ i = 11; }}
利用構(gòu)造函數(shù)，能夠把 i 的值初始化為 11。
初始化順序
首先先來(lái)看一下有哪些需要探討的初始化順序
靜態(tài)屬性：static 開(kāi)頭定義的屬性靜態(tài)方法塊：static {} 包起來(lái)的代碼塊普通屬性：非 static 定義的屬性普通方法塊：{} 包起來(lái)的代碼塊構(gòu)造函數(shù)：類名相同的方法方法：普通方法publicclassLifeCycle{// 靜態(tài)屬性privatestatic String staticField = getStaticField();// 靜態(tài)方法塊static {System.out.println(staticField); System.out.println("靜態(tài)方法塊初始化"); }// 普通屬性private String field = getField();// 普通方法塊 { System.out.println(field); }// 構(gòu)造函數(shù)publicLifeCycle(){ System.out.println("構(gòu)造函數(shù)初始化"); }publicstatic String getStaticField(){ String statiFiled = "Static Field Initial";return statiFiled; }publicstatic String getField(){ String filed = "Field Initial";return filed; } // 主函數(shù)publicstaticvoidmain(String[] argc){new LifeCycle(); }}
這段代碼的執(zhí)行結(jié)果就反應(yīng)了它的初始化順序
靜態(tài)屬性初始化 靜態(tài)方法塊初始化 普通屬性初始化 普通方法塊初始化 構(gòu)造函數(shù)初始化
數(shù)組初始化
數(shù)組是相同類型的、用一個(gè)標(biāo)識(shí)符名稱封裝到一起的一個(gè)對(duì)象序列或基本類型數(shù)據(jù)序列。數(shù)組是通過(guò)方括號(hào)下標(biāo)操作符 [] 來(lái)定義使用。
一般數(shù)組是這么定義的
int[] a1;//或者int a1[];
兩種格式的含義是一樣的。
直接給每個(gè)元素賦值 : int array[4] = {1,2,3,4};給一部分賦值，后面的都為 0 ：int array[4] = {1,2};由賦值參數(shù)個(gè)數(shù)決定數(shù)組的個(gè)數(shù) ：int array[] = {1,2};可變參數(shù)列表
Java 中一種數(shù)組冷門的用法就是可變參數(shù) ，可變參數(shù)的定義如下
publicintadd(int... numbers){int sum = 0;for(int num : numbers){ sum += num; }return sum;}
然后，你可以使用下面這幾種方式進(jìn)行可變參數(shù)的調(diào)用
add(); // 不傳參數(shù)add(1); // 傳遞一個(gè)參數(shù)add(2,1); // 傳遞多個(gè)參數(shù)add(new Integer[] {1, 3, 2}); // 傳遞數(shù)組
對(duì)象的銷毀
雖然 Java 語(yǔ)言是基于 C++ 的，但是它和 C/C++ 一個(gè)重要的特征就是不需要手動(dòng)管理對(duì)象的銷毀工作。在著名的一書(shū) 《深入理解 Java 虛擬機(jī)》中提到一個(gè)觀點(diǎn)
在 Java 中，我們不再需要手動(dòng)管理對(duì)象的銷毀，它是由 Java 虛擬機(jī)進(jìn)行管理和銷毀的。雖然我們不需要手動(dòng)管理對(duì)象，但是你需要知道 對(duì)象作用域 這個(gè)概念。
對(duì)象作用域
J多數(shù)語(yǔ)言都有作用域(scope) 這個(gè)概念。作用域決定了其內(nèi)部定義的變量名的可見(jiàn)性和生命周期。在 C、C++ 和 Java 中，作用域通常由 {} 的位置來(lái)決定，例如
{int a = 11; {int b = 12; }}
a 變量會(huì)在兩個(gè) {} 作用域內(nèi)有效，而 b 變量的值只能在它自己的 {} 內(nèi)有效。
雖然存在作用域，但是不允許這樣寫(xiě)
{int x = 11; {int x = 12; }}
這種寫(xiě)法在 C/C++ 中是可以的，但是在 Java 中不允許這樣寫(xiě)，因?yàn)?Java 設(shè)計(jì)者認(rèn)為這樣寫(xiě)會(huì)導(dǎo)致程序混亂。
###this 和 super
this 和 super 都是 Java 中的關(guān)鍵字
this 表示的當(dāng)前對(duì)象，this 可以調(diào)用方法、調(diào)用屬性和指向?qū)ο蟊旧怼his 在 Java 中的使用一般有三種：指向當(dāng)前對(duì)象
publicclassApple{int i = 0;Apple eatApple(){ i++;returnthis; }publicstaticvoidmain(String[] args){ Apple apple = new Apple(); apple.eatApple().eatApple(); }}
這段代碼比較精妙，精妙在哪呢，我一個(gè) eatApple() 方法竟然可以調(diào)用多次，你在后面還可以繼續(xù)調(diào)用，這就很神奇了，為啥呢？其實(shí)就是 this 在作祟了，我在 eatApple 方法中加了一個(gè) return this 的返回值，也就是說(shuō)哪個(gè)對(duì)象調(diào)用 eatApple 方法都能返回對(duì)象的自身。
this 還可以修飾屬性，最常見(jiàn)的就是在構(gòu)造方法中使用 this ，如下所示
publicclassApple{privateint num;publicApple(int num){this.num = num; }publicstaticvoidmain(String[] args){new Apple(10); }}
main 方法中傳遞了一個(gè) int 值為 10 的參數(shù)，它表示的就是蘋(píng)果的數(shù)量，并把這個(gè)數(shù)量賦給了 num 全局變量。所以 num 的值現(xiàn)在就是 10。
this 還可以和構(gòu)造函數(shù)一起使用，充當(dāng)一個(gè)全局關(guān)鍵字的效果
publicclassApple{privateint num;private String color;publicApple(int num){this(num,"紅色"); }publicApple(String color){this(1,color); }publicApple(int num, String color){this.num = num;this.color = color; }}
你會(huì)發(fā)現(xiàn)上面這段代碼使用的不是 this, 而是 this(參數(shù))。它相當(dāng)于調(diào)用了其他構(gòu)造方法，然后傳遞參數(shù)進(jìn)去。這里注意一點(diǎn)：this() 必須放在構(gòu)造方法的第一行，否則編譯不通過(guò)
如果你把 this 理解為指向自身的一個(gè)引用，那么 super 就是指向父類的一個(gè)引用。super 關(guān)鍵字和 this 一樣，你可以使用 super.對(duì)象 來(lái)引用父類的成員，如下
publicclassFruit{int num; String color;publicvoideat(){ System.out.println("eat Fruit"); }}publicclassAppleextendsFruit{@Overridepublicvoideat(){super.num = 10; System.out.println("eat " + num + " Apple"); }}
你也可以使用 super(參數(shù)) 來(lái)調(diào)用父類的構(gòu)造函數(shù)，這里不再舉例子了。
下面為你匯總了 this 關(guān)鍵字和 super 關(guān)鍵字的比較。
訪問(wèn)控制權(quán)限
訪問(wèn)控制權(quán)限又稱為封裝，它是面向?qū)ο笕筇匦灾械囊环N，我之前在學(xué)習(xí)過(guò)程中經(jīng)常會(huì)忽略封裝，心想這不就是一個(gè)訪問(wèn)修飾符么，怎么就是三大特性的必要條件了？后來(lái)我才知道，如果你信任的下屬對(duì)你隱瞞 bug，你是根本不知道的。
訪問(wèn)控制權(quán)限其實(shí)最核心就是一點(diǎn)：只對(duì)需要的類可見(jiàn)。
Java中成員的訪問(wèn)權(quán)限共有四種，分別是 public、protected、default、private，它們的可見(jiàn)性如下
繼承
繼承是所有 OOP(Object Oriented Programming) 語(yǔ)言和 Java 語(yǔ)言都不可或缺的一部分。只要我們創(chuàng)建了一個(gè)類，就隱式的繼承自 Object 父類，只不過(guò)沒(méi)有指定。如果你顯示指定了父類，那么你繼承于父類，而你的父類繼承于 Object 類。
繼承的關(guān)鍵字是 extends ，如上圖所示，如果使用了 extends 顯示指定了繼承，那么我們可以說(shuō) Father 是父類，而 Son 是子類，用代碼表示如下
classFather{}classSonextendsFather{}
繼承雙方擁有某種共性的特征
classFather{publicvoidfeature(){ System.out.println("父親的特征"); }}classSonextendsFather{}
如果 Son 沒(méi)有實(shí)現(xiàn)自己的方法的話，那么默認(rèn)就是用的是父類的 feature 方法。如果子類實(shí)現(xiàn)了自己的 feature 方法，那么就相當(dāng)于是重寫(xiě)了父類的 feature 方法，這也是我們上面提到的重寫(xiě)了。
多態(tài)
多態(tài)指的是同一個(gè)行為具有多個(gè)不同表現(xiàn)形式。是指一個(gè)類實(shí)例（對(duì)象）的相同方法在不同情形下具有不同表現(xiàn)形式。封裝和繼承是多態(tài)的基礎(chǔ)，也就是說(shuō)，多態(tài)只是一種表現(xiàn)形式而已。
如何實(shí)現(xiàn)多態(tài)？多態(tài)的實(shí)現(xiàn)具有三種充要條件
繼承重寫(xiě)父類方法父類引用指向子類對(duì)象比如下面這段代碼
publicclassFruit{int num;publicvoideat(){ System.out.println("eat Fruit"); }}publicclassAppleextendsFruit{@Overridepublicvoideat(){super.num = 10; System.out.println("eat " + num + " Apple"); }publicstaticvoidmain(String[] args){ Fruit fruit = new Apple(); fruit.eat(); }}
你可以發(fā)現(xiàn) main 方法中有一個(gè)很神奇的地方，F(xiàn)ruit fruit = new Apple()，F(xiàn)ruit 類型的對(duì)象竟然指向了 Apple 對(duì)象的引用，這其實(shí)就是多態(tài) -> 父類引用指向子類對(duì)象，因?yàn)?Apple 繼承于 Fruit，并且重寫(xiě)了 eat 方法，所以能夠表現(xiàn)出來(lái)多種狀態(tài)的形式。
組合
組合其實(shí)不難理解，就是將對(duì)象引用置于新類中即可。組合也是一種提高類的復(fù)用性的一種方式。如果你想讓類具有更多的擴(kuò)展功能，你需要記住一句話多用組合，少用繼承。
publicclassSoccerPlayer{private String name;private Soccer soccer;}publicclassSoccer{private String soccerName; }
代碼中 SoccerPlayer 引用了 Soccer 類，通過(guò)引用 Soccer 類，來(lái)達(dá)到調(diào)用 soccer 中的屬性和方法。
組合和繼承是有區(qū)別的，它們的主要區(qū)別如下。
關(guān)于繼承和組合孰優(yōu)孰劣的爭(zhēng)論沒(méi)有結(jié)果，只要發(fā)揮各自的長(zhǎng)處和優(yōu)點(diǎn)即可，一般情況下，組合和繼承也是一對(duì)可以連用的好兄弟。
代理
除了繼承和組合外，另外一種值得探討的關(guān)系模型稱為 代理。代理的大致描述是，A 想要調(diào)用 B 類的方法，A 不直接調(diào)用，A 會(huì)在自己的類中創(chuàng)建一個(gè) B 對(duì)象的代理，再由代理調(diào)用 B 的方法。例如如下代碼
publicclassDestination{publicvoidtodo(){ System.out.println("control..."); }}publicclassDevice{private String name;private Destination destination;private DeviceController deviceController;publicvoidcontrol(Destination destination){ destination.todo(); }}publicclassDeviceController{private Device name;private Destination destination;publicvoidcontrol(Destination destination){ destination.todo(); }}
向上轉(zhuǎn)型
向上轉(zhuǎn)型代表了父類與子類之間的關(guān)系，其實(shí)父類和子類之間不僅僅有向上轉(zhuǎn)型，還有向下轉(zhuǎn)型，它們的轉(zhuǎn)型后的范圍不一樣
向上轉(zhuǎn)型：通過(guò)子類對(duì)象(小范圍)轉(zhuǎn)化為父類對(duì)象(大范圍)，這種轉(zhuǎn)換是自動(dòng)完成的，不用強(qiáng)制。向下轉(zhuǎn)型 : 通過(guò)父類對(duì)象(大范圍)實(shí)例化子類對(duì)象(小范圍)，這種轉(zhuǎn)換不是自動(dòng)完成的，需要強(qiáng)制指定。static
static 是 Java 中的關(guān)鍵字，它的意思是 靜態(tài)的，static 可以用來(lái)修飾成員變量和方法，static 用在沒(méi)有創(chuàng)建對(duì)象的情況下調(diào)用 方法/變量。
用 static 聲明的成員變量為靜態(tài)成員變量，也成為類變量。類變量的生命周期和類相同，在整個(gè)應(yīng)用程序執(zhí)行期間都有效。static String name = "cxuan";
使用 static 修飾的方法稱為靜態(tài)方法，靜態(tài)方法能夠直接使用類名.方法名 進(jìn)行調(diào)用。由于靜態(tài)方法不依賴于任何對(duì)象就可以直接訪問(wèn)，因此對(duì)于靜態(tài)方法來(lái)說(shuō)，是沒(méi)有 this 關(guān)鍵字的，實(shí)例變量都會(huì)有 this 關(guān)鍵字。在靜態(tài)方法中不能訪問(wèn)類的非靜態(tài)成員變量和非靜態(tài)方法，staticvoidprintMessage(){ System.out.println("cxuan is writing the article");}
static 除了修飾屬性和方法外，還有靜態(tài)代碼塊 的功能，可用于類的初始化操作。進(jìn)而提升程序的性能。
publicclassStaicBlock{static{ System.out.println("I'm A static code block"); }}
由于靜態(tài)代碼塊隨著類的加載而執(zhí)行，因此，很多時(shí)候會(huì)將只需要進(jìn)行一次的初始化操作放在 static 代碼塊中進(jìn)行。
final
final 的意思是最后的、最終的，它可以修飾類、屬性和方法。
final 修飾類時(shí)，表明這個(gè)類不能被繼承。final 類中的成員變量可以根據(jù)需要設(shè)為 final，但是要注意 final 類中的所有成員方法都會(huì)被隱式地指定為 final 方法。final 修飾方法時(shí)，表明這個(gè)方法不能被任何子類重寫(xiě)，因此，如果只有在想明確禁止該方法在子類中被覆蓋的情況下才將方法設(shè)置為 final。final 修飾變量分為兩種情況，一種是修飾基本數(shù)據(jù)類型，表示數(shù)據(jù)類型的值不能被修改；一種是修飾引用類型，表示對(duì)其初始化之后便不能再讓其指向另一個(gè)對(duì)象。
接口和抽象類
接口
接口相當(dāng)于就是對(duì)外的一種約定和標(biāo)準(zhǔn)，這里拿操作系統(tǒng)舉例子，為什么會(huì)有操作系統(tǒng)？就會(huì)為了屏蔽軟件的復(fù)雜性和硬件的簡(jiǎn)單性之間的差異，為軟件提供統(tǒng)一的標(biāo)準(zhǔn)。
在 Java 語(yǔ)言中，接口是由 interface 關(guān)鍵字來(lái)表示的，比如我們可以向下面這樣定義一個(gè)接口
publicinterfaceCxuanGoodJob{}
比如我們定義了一個(gè) CxuanGoodJob 的接口，然后你就可以在其內(nèi)部定義 cxuan 做的好的那些事情，比如 cxuan 寫(xiě)的文章不錯(cuò)。
publicinterfaceCxuanGoodJob{voidwriteWell();}
這里隱含了一些接口的特征：
interface 接口是一個(gè)完全抽象的類，他不會(huì)提供任何方法的實(shí)現(xiàn)，只是會(huì)進(jìn)行方法的定義。接口中只能使用兩種訪問(wèn)修飾符，一種是 public，它對(duì)整個(gè)項(xiàng)目可見(jiàn)；一種是 default 缺省值，它只具有包訪問(wèn)權(quán)限。接口只提供方法的定義，接口沒(méi)有實(shí)現(xiàn)，但是接口可以被其他類實(shí)現(xiàn)。也就是說(shuō)，實(shí)現(xiàn)接口的類需要提供方法的實(shí)現(xiàn)，實(shí)現(xiàn)接口使用 implements 關(guān)鍵字來(lái)表示，一個(gè)接口可以有多個(gè)實(shí)現(xiàn)。classCXuanWriteWellimplementsCxuanGoodJob{@OverridepublicvoidwriteWell(){ System.out.println("Cxuan write Java is vary well"); }}
接口不能被實(shí)例化，所以接口中不能有任何構(gòu)造方法，你定義構(gòu)造方法編譯會(huì)出錯(cuò)。接口的實(shí)現(xiàn)比如實(shí)現(xiàn)接口的全部方法，否則必須定義為抽象類，這就是我們下面要說(shuō)的內(nèi)容抽象類
抽象類是一種抽象能力弱于接口的類，在 Java 中，抽象類使用 abstract 關(guān)鍵字來(lái)表示。如果把接口形容為狗這個(gè)物種，那么抽象類可以說(shuō)是毛發(fā)是白色、小體的品種，而實(shí)現(xiàn)類可以是具體的類，比如說(shuō)是博美、泰迪等。你可以像下面這樣定義抽象類
publicinterfaceDog{voidFurColor();}abstractclassWhiteDogimplementsDog{publicvoidFurColor(){ System.out.println("Fur is white"); }abstractvoidSmallBody();}
在抽象類中，具有如下特征
如果一個(gè)類中有抽象方法，那么這個(gè)類一定是抽象類，也就是說(shuō)，使用關(guān)鍵字 abstract 修飾的方法一定是抽象方法，具有抽象方法的類一定是抽象類。實(shí)現(xiàn)類方法中只有方法具體的實(shí)現(xiàn)。抽象類中不一定只有抽象方法，抽象類中也可以有具體的方法，你可以自己去選擇是否實(shí)現(xiàn)這些方法。抽象類中的約束不像接口那么嚴(yán)格，你可以在抽象類中定義 構(gòu)造方法、抽象方法、普通屬性、方法、靜態(tài)屬性和靜態(tài)方法抽象類和接口一樣不能被實(shí)例化，實(shí)例化只能實(shí)例化具體的類
異常
異常是程序經(jīng)常會(huì)出現(xiàn)的，發(fā)現(xiàn)錯(cuò)誤的最佳時(shí)機(jī)是在編譯階段，也就是你試圖在運(yùn)行程序之前。但是，在編譯期間并不能找到所有的錯(cuò)誤，有一些 NullPointerException 和 ClassNotFoundException 異常在編譯期找不到，這些異常是 RuntimeException 運(yùn)行時(shí)異常，這些異常往往在運(yùn)行時(shí)才能被發(fā)現(xiàn)。
我們寫(xiě) Java 程序經(jīng)常會(huì)出現(xiàn)兩種問(wèn)題，一種是 java.lang.Exception ，一種是 java.lang.Error，都用來(lái)表示出現(xiàn)了異常情況，下面就針對(duì)這兩種概念進(jìn)行理解。
認(rèn)識(shí) Exception
Exception 位于 java.lang 包下，它是一種頂級(jí)接口，繼承于 Throwable 類，Exception 類及其子類都是 Throwable 的組成條件，是程序出現(xiàn)的合理情況。
在認(rèn)識(shí) Exception 之前，有必要先了解一下什么是 Throwable。
什么是 Throwable
Throwable 類是 Java 語(yǔ)言中所有錯(cuò)誤(errors)和異常(exceptions)的父類。只有繼承于 Throwable 的類或者其子類才能夠被拋出，還有一種方式是帶有 Java 中的 @throw 注解的類也可以拋出。
在Java規(guī)范中，對(duì)非受查異常和受查異常的定義是這樣的：
The unchecked exception classes are the run-time exception classes and the error classes.The checked exception classes are all exception classes other than the unchecked exception classes. That is, the checked exception classes are Throwable and all its subclasses other than RuntimeException and its subclasses and Errorand its subclasses.
也就是說(shuō)，除了 RuntimeException 和其子類，以及error和其子類，其它的所有異常都是 checkedException。
那么，按照這種邏輯關(guān)系，我們可以對(duì) Throwable 及其子類進(jìn)行歸類分析
可以看到，Throwable 位于異常和錯(cuò)誤的最頂層，我們查看 Throwable 類中發(fā)現(xiàn)它的方法和屬性有很多，我們只討論其中幾個(gè)比較常用的
// 返回拋出異常的詳細(xì)信息public string getMessage();public string getLocalizedMessage();//返回異常發(fā)生時(shí)的簡(jiǎn)要描述publicpublic String toString()；// 打印異常信息到標(biāo)準(zhǔn)輸出流上publicvoidprintStackTrace();publicvoidprintStackTrace(PrintStream s);publicvoidprintStackTrace(PrintWriter s)// 記錄棧幀的的當(dāng)前狀態(tài)publicsynchronized Throwable fillInStackTrace();
此外，因?yàn)?Throwable 的父類也是 Object，所以常用的方法還有繼承其父類的getClass() 和 getName() 方法。
常見(jiàn)的 Exception
下面我們回到 Exception 的探討上來(lái)，現(xiàn)在你知道了 Exception 的父類是 Throwable，并且 Exception 有兩種異常，一種是 RuntimeException ；一種是 CheckedException，這兩種異常都應(yīng)該去捕獲。
下面列出了一些 Java 中常見(jiàn)的異常及其分類，這塊面試官也可能讓你舉出幾個(gè)常見(jiàn)的異常情況并將其分類
RuntimeException
UncheckedException
與 Exception 有關(guān)的 Java 關(guān)鍵字
那么 Java 中是如何處理這些異常的呢？在 Java 中有這幾個(gè)關(guān)鍵字 throws、throw、try、finally、catch 下面我們分別來(lái)探討一下
throws 和 throw
在 Java 中，異常也就是一個(gè)對(duì)象，它能夠被程序員自定義拋出或者應(yīng)用程序拋出，必須借助于 throws 和 throw 語(yǔ)句來(lái)定義拋出異常。
throws 和 throw 通常是成對(duì)出現(xiàn)的，例如
staticvoidcacheException()throws Exception{thrownew Exception();}
throw 語(yǔ)句用在方法體內(nèi)，表示拋出異常，由方法體內(nèi)的語(yǔ)句處理。throws 語(yǔ)句用在方法聲明后面，表示再拋出異常，由該方法的調(diào)用者來(lái)處理。
throws 主要是聲明這個(gè)方法會(huì)拋出這種類型的異常，使它的調(diào)用者知道要捕獲這個(gè)異常。throw 是具體向外拋異常的動(dòng)作，所以它是拋出一個(gè)異常實(shí)例。
try 、finally 、catch
這三個(gè)關(guān)鍵字主要有下面幾種組合方式 try...catch 、try...finally、try...catch...finally。
try...catch 表示對(duì)某一段代碼可能拋出異常進(jìn)行的捕獲，如下
staticvoidcacheException()throws Exception{try { System.out.println("1"); }catch (Exception e){ e.printStackTrace(); }}
try...finally 表示對(duì)一段代碼不管執(zhí)行情況如何，都會(huì)走 finally 中的代碼
staticvoidcacheException()throws Exception{for (int i = 0; i < 5; i++) { System.out.println("enter: i=" + i);try { System.out.println("execute: i=" + i);continue; } finally { System.out.println("leave: i=" + i); } }}
try...catch...finally 也是一樣的，表示對(duì)異常捕獲后，再走 finally 中的代碼邏輯。
什么是 Error
Error 是程序無(wú)法處理的錯(cuò)誤，表示運(yùn)行應(yīng)用程序中較嚴(yán)重問(wèn)題。大多數(shù)錯(cuò)誤與代碼編寫(xiě)者執(zhí)行的操作無(wú)關(guān)，而表示代碼運(yùn)行時(shí) JVM（Java 虛擬機(jī)）出現(xiàn)的問(wèn)題。這些錯(cuò)誤是不可檢查的，因?yàn)樗鼈冊(cè)趹?yīng)用程序的控制和處理能力之 外，而且絕大多數(shù)是程序運(yùn)行時(shí)不允許出現(xiàn)的狀況，比如 OutOfMemoryError 和 StackOverflowError異常的出現(xiàn)會(huì)有幾種情況，這里需要先介紹一下 Java 內(nèi)存模型 JDK1.7。
其中包括兩部分，由所有線程共享的數(shù)據(jù)區(qū)和線程隔離的數(shù)據(jù)區(qū)組成，在上面的 Java 內(nèi)存模型中，只有程序計(jì)數(shù)器是不會(huì)發(fā)生 OutOfMemoryError 情況的區(qū)域，程序計(jì)數(shù)器控制著計(jì)算機(jī)指令的分支、循環(huán)、跳轉(zhuǎn)、異常處理和線程恢復(fù)，并且程序計(jì)數(shù)器是每個(gè)線程私有的。
什么是線程私有：表示的就是各條線程之間互不影響，獨(dú)立存儲(chǔ)的內(nèi)存區(qū)域。
如果應(yīng)用程序執(zhí)行的是 Java 方法，那么這個(gè)計(jì)數(shù)器記錄的就是虛擬機(jī)字節(jié)碼指令的地址；如果正在執(zhí)行的是 Native 方法，這個(gè)計(jì)數(shù)器值則為空(Undefined)。
除了程序計(jì)數(shù)器外，其他區(qū)域：方法區(qū)(Method Area)、虛擬機(jī)棧(VM Stack)、本地方法棧(Native Method Stack) 和 堆(Heap) 都是可能發(fā)生 OutOfMemoryError 的區(qū)域。
虛擬機(jī)棧：如果線程請(qǐng)求的棧深度大于虛擬機(jī)棧所允許的深度，將會(huì)出現(xiàn) StackOverflowError 異常；如果虛擬機(jī)動(dòng)態(tài)擴(kuò)展無(wú)法申請(qǐng)到足夠的內(nèi)存，將出現(xiàn) OutOfMemoryError。本地方法棧和虛擬機(jī)棧一樣堆：Java 堆可以處于物理上不連續(xù)，邏輯上連續(xù)，就像我們的磁盤空間一樣，如果堆中沒(méi)有內(nèi)存完成實(shí)例分配，并且堆無(wú)法擴(kuò)展時(shí)，將會(huì)拋出 OutOfMemoryError。方法區(qū)：方法區(qū)無(wú)法滿足內(nèi)存分配需求時(shí)，將拋出 OutOfMemoryError 異常。在 Java 中，你可以把異常理解為是一種能夠提高你程序健壯性的機(jī)制，它能夠讓你在編寫(xiě)代碼中注意這些問(wèn)題，也可以說(shuō)，如果你寫(xiě)代碼不會(huì)注意這些異常情況，你是無(wú)法成為一位硬核程序員的。
內(nèi)部類
距今為止，我們了解的都是普通類的定義，那就是直接在 IDEA 中直接新建一個(gè) class 。
新建完成后，你就會(huì)擁有一個(gè) class 文件的定義，這種操作太簡(jiǎn)單了，時(shí)間長(zhǎng)了就會(huì)枯燥，我們年輕人多需要更新潮和騷氣的寫(xiě)法，好吧，既然你提到了那就使用 內(nèi)部類吧，這是一種有用而且騷氣的定義類的方式，內(nèi)部類的定義非常簡(jiǎn)單：可以將一個(gè)類的定義放在另一個(gè)類的內(nèi)部，這就是內(nèi)部類。
內(nèi)部類是一種非常有用的特性，定義在類內(nèi)部的類，持有外部類的引用，但卻對(duì)其他外部類不可見(jiàn)，看起來(lái)就像是一種隱藏代碼的機(jī)制，就和 弗蘭奇將軍 似的，弗蘭奇可以和弗蘭奇將軍進(jìn)行通訊，但是外面的敵人卻無(wú)法直接攻擊到弗蘭奇本體。
下面我們就來(lái)聊一聊創(chuàng)建內(nèi)部類的方式。
創(chuàng)建內(nèi)部類
定義內(nèi)部類非常簡(jiǎn)單，就是直接將一個(gè)類定義在外圍類的里面，如下代碼所示
publicclassOuterClass{private String name ;privateint age;classInnerClass{publicInnerClass(){ name = "cxuan"; age = 25; } }}
在這段代碼中，InnerClass 就是 OuterClass 的一個(gè)內(nèi)部類。也就是說(shuō)，每個(gè)內(nèi)部類都能獨(dú)立地繼承一個(gè)（接口的）實(shí)現(xiàn)，所以無(wú)論外圍類是否已經(jīng)繼承了某個(gè)（接口的）實(shí)現(xiàn)，對(duì)于內(nèi)部類都沒(méi)有影響。這也是隱藏了內(nèi)部實(shí)現(xiàn)細(xì)節(jié)。內(nèi)部類擁有外部類的訪問(wèn)權(quán)。
內(nèi)部類不僅僅能夠定義在類的內(nèi)部，還可以定義在方法和作用域內(nèi)部，這種被稱為局部?jī)?nèi)部類，除此之外，還有匿名內(nèi)部類、內(nèi)部類可以實(shí)現(xiàn) Java 中的 多重繼承。下面是定義內(nèi)部類的方式
一個(gè)在方法中定義的類(局部?jī)?nèi)部類)一個(gè)定義在作用域內(nèi)的類，這個(gè)作用域在方法的內(nèi)部(成員內(nèi)部類)一個(gè)實(shí)現(xiàn)了接口的匿名類(匿名內(nèi)部類)一個(gè)匿名類，它擴(kuò)展了非默認(rèn)構(gòu)造器的類一個(gè)匿名類，執(zhí)行字段初始化操作一個(gè)匿名類，它通過(guò)實(shí)例初始化實(shí)現(xiàn)構(gòu)造由于每個(gè)類都會(huì)產(chǎn)生一個(gè) .class 文件，其中包含了如何創(chuàng)建該類型的對(duì)象的全部信息，那么，如何表示內(nèi)部類的信息呢？可以使用 $ 來(lái)表示，比如 OuterClass$InnerClass.class。
集合
集合在我們的日常開(kāi)發(fā)中所使用的次數(shù)簡(jiǎn)直太多了，你已經(jīng)把它們都用的熟透了，但是作為一名合格的程序員，你不僅要了解它的基本用法，你還要了解它的源碼；存在即合理，你還要了解它是如何設(shè)計(jì)和實(shí)現(xiàn)的，你還要了解它的衍生過(guò)程。
這篇博客就來(lái)詳細(xì)介紹一下 Collection 這個(gè)龐大集合框架的家族體系和成員，讓你了解它的設(shè)計(jì)與實(shí)現(xiàn)。
是時(shí)候祭出這張神圖了
首先來(lái)介紹的就是列表爺爺輩兒的接口- Iterator
Iterable 接口
實(shí)現(xiàn)此接口允許對(duì)象成為 for-each 循環(huán)的目標(biāo)，也就是增強(qiáng) for 循環(huán)，它是 Java 中的一種語(yǔ)法糖。
List<Object> list = new ArrayList();for (Object obj: list){}
除了實(shí)現(xiàn)此接口的對(duì)象外，數(shù)組也可以用 for-each 循環(huán)遍歷，如下：
Object[] list = new Object[10];for (Object obj: list){}
其他遍歷方式
jdk 1.8之前Iterator只有 iterator 一個(gè)方法，就是
Iterator<T> iterator();
實(shí)現(xiàn)次接口的方法能夠創(chuàng)建一個(gè)輕量級(jí)的迭代器，用于安全的遍歷元素，移除元素，添加元素。這里面涉及到一個(gè) fail-fast 機(jī)制。
總之一點(diǎn)就是能創(chuàng)建迭代器進(jìn)行元素的添加和刪除的話，就盡量使用迭代器進(jìn)行添加和刪除。
也可以使用迭代器的方式進(jìn)行遍歷
for(Iterator it = coll.iterator(); it.hasNext(); ){ System.out.println(it.next());}
頂層接口
Collection 是一個(gè)頂層接口，它主要用來(lái)定義集合的約定
List 接口也是一個(gè)頂層接口，它繼承了 Collection 接口 ，同時(shí)也是 ArrayList、LinkedList 等集合元素的父類
Set 接口位于與 List 接口同級(jí)的層次上，它同時(shí)也繼承了 Collection 接口。Set 接口提供了額外的規(guī)定。它對(duì)add、equals、hashCode 方法提供了額外的標(biāo)準(zhǔn)。
Queue 是和 List、Set 接口并列的 Collection 的三大接口之一。Queue 的設(shè)計(jì)用來(lái)在處理之前保持元素的訪問(wèn)次序。除了 Collection 基礎(chǔ)的操作之外，隊(duì)列提供了額外的插入，讀取，檢查操作。
SortedSet 接口直接繼承于 Set 接口，使用 Comparable 對(duì)元素進(jìn)行自然排序或者使用 Comparator 在創(chuàng)建時(shí)對(duì)元素提供定制的排序規(guī)則。set 的迭代器將按升序元素順序遍歷集合。
Map 是一個(gè)支持 key-value 存儲(chǔ)的對(duì)象，Map 不能包含重復(fù)的 key，每個(gè)鍵最多映射一個(gè)值。這個(gè)接口代替了Dictionary 類，Dictionary 是一個(gè)抽象類而不是接口。
ArrayList
ArrayList 是實(shí)現(xiàn)了 List 接口的可擴(kuò)容數(shù)組(動(dòng)態(tài)數(shù)組)，它的內(nèi)部是基于數(shù)組實(shí)現(xiàn)的。它的具體定義如下：
publicclassArrayList<E> extendsAbstractList<E> implementsList<E>, RandomAccess, Cloneable, java.io.Serializable{...}
ArrayList 可以實(shí)現(xiàn)所有可選擇的列表操作，允許所有的元素，包括空值。ArrayList 還提供了內(nèi)部存儲(chǔ) list 的方法，它能夠完全替代 Vector，只有一點(diǎn)例外，ArrayList 不是線程安全的容器。ArrayList 有一個(gè)容量的概念，這個(gè)數(shù)組的容量就是 List 用來(lái)存儲(chǔ)元素的容量。ArrayList 不是線程安全的容器，如果多個(gè)線程中至少有兩個(gè)線程修改了 ArrayList 的結(jié)構(gòu)的話就會(huì)導(dǎo)致線程安全問(wèn)題，作為替代條件可以使用線程安全的 List，應(yīng)使用 Collections.synchronizedList 。List list = Collections.synchronizedList(new ArrayList(...))
ArrayList 具有 fail-fast 快速失敗機(jī)制，能夠?qū)?ArrayList 作出失敗檢測(cè)。當(dāng)在迭代集合的過(guò)程中該集合在結(jié)構(gòu)上發(fā)生改變的時(shí)候，就有可能會(huì)發(fā)生 fail-fast，即拋出 ConcurrentModificationException異常。Vector
Vector 同 ArrayList 一樣，都是基于數(shù)組實(shí)現(xiàn)的，只不過(guò) Vector 是一個(gè)線程安全的容器，它對(duì)內(nèi)部的每個(gè)方法都簡(jiǎn)單粗暴的上鎖，避免多線程引起的安全性問(wèn)題，但是通常這種同步方式需要的開(kāi)銷比較大，因此，訪問(wèn)元素的效率要遠(yuǎn)遠(yuǎn)低于 ArrayList。
還有一點(diǎn)在于擴(kuò)容上，ArrayList 擴(kuò)容后的數(shù)組長(zhǎng)度會(huì)增加 50%，而 Vector 的擴(kuò)容長(zhǎng)度后數(shù)組會(huì)增加一倍。
LinkedList 類
LinkedList 是一個(gè)雙向鏈表，允許存儲(chǔ)任何元素(包括 null )。它的主要特性如下：
LinkedList 所有的操作都可以表現(xiàn)為雙向性的，索引到鏈表的操作將遍歷從頭到尾，視哪個(gè)距離近為遍歷順序。注意這個(gè)實(shí)現(xiàn)也不是線程安全的，如果多個(gè)線程并發(fā)訪問(wèn)鏈表，并且至少其中的一個(gè)線程修改了鏈表的結(jié)構(gòu)，那么這個(gè)鏈表必須進(jìn)行外部加鎖?；蛘呤褂肔ist list = Collections.synchronizedList(new LinkedList(...))
Stack
堆棧是我們常說(shuō)的后入先出(吃了吐)的容器 。它繼承了 Vector 類，提供了通常用的 push 和 pop 操作，以及在棧頂?shù)?peek 方法，測(cè)試 stack 是否為空的 empty 方法，和一個(gè)尋找與棧頂距離的 search 方法。
第一次創(chuàng)建棧，不包含任何元素。一個(gè)更完善，可靠性更強(qiáng)的 LIFO 棧操作由 Deque 接口和他的實(shí)現(xiàn)提供，應(yīng)該優(yōu)先使用這個(gè)類
Deque<Integer> stack = new ArrayDeque<Integer>()
HashSet
HashSet 是 Set 接口的實(shí)現(xiàn)類，由哈希表支持(實(shí)際上 HashSet 是 HashMap 的一個(gè)實(shí)例)。它不能保證集合的迭代順序。這個(gè)類允許 null 元素。
注意這個(gè)實(shí)現(xiàn)不是線程安全的。如果多線程并發(fā)訪問(wèn) HashSet，并且至少一個(gè)線程修改了set，必須進(jìn)行外部加鎖?；蛘呤褂?Collections.synchronizedSet() 方法重寫(xiě)。這個(gè)實(shí)現(xiàn)支持 fail-fast 機(jī)制。TreeSet
TreeSet 是一個(gè)基于 TreeMap 的 NavigableSet 實(shí)現(xiàn)。這些元素使用他們的自然排序或者在創(chuàng)建時(shí)提供的Comparator 進(jìn)行排序，具體取決于使用的構(gòu)造函數(shù)。
此實(shí)現(xiàn)為基本操作 add,remove 和 contains 提供了 log(n) 的時(shí)間成本。注意這個(gè)實(shí)現(xiàn)不是線程安全的。如果多線程并發(fā)訪問(wèn) TreeSet，并且至少一個(gè)線程修改了 set，必須進(jìn)行外部加鎖?；蛘呤褂肧ortedSet s = Collections.synchronizedSortedSet(new TreeSet(...))
這個(gè)實(shí)現(xiàn)持有 fail-fast 機(jī)制。LinkedHashSet 類
LinkedHashSet 繼承于 Set，先來(lái)看一下 LinkedHashSet 的繼承體系：
LinkedHashSet 是 Set 接口的 Hash 表和 LinkedList 的實(shí)現(xiàn)。這個(gè)實(shí)現(xiàn)不同于 HashSet 的是它維護(hù)著一個(gè)貫穿所有條目的雙向鏈表。此鏈表定義了元素插入集合的順序。注意：如果元素重新插入，則插入順序不會(huì)受到影響。
LinkedHashSet 有兩個(gè)影響其構(gòu)成的參數(shù)：初始容量和加載因子。它們的定義與 HashSet 完全相同。但請(qǐng)注意：對(duì)于 LinkedHashSet，選擇過(guò)高的初始容量值的開(kāi)銷要比 HashSet 小，因?yàn)?LinkedHashSet 的迭代次數(shù)不受容量影響。注意 LinkedHashSet 也不是線程安全的，如果多線程同時(shí)訪問(wèn) LinkedHashSet，必須加鎖，或者通過(guò)使用Collections.synchronizedSet
該類也支持fail-fast機(jī)制PriorityQueue
PriorityQueue 是 AbstractQueue 的實(shí)現(xiàn)類，優(yōu)先級(jí)隊(duì)列的元素根據(jù)自然排序或者通過(guò)在構(gòu)造函數(shù)時(shí)期提供Comparator 來(lái)排序，具體根據(jù)構(gòu)造器判斷。PriorityQueue 不允許 null 元素。
隊(duì)列的頭在某種意義上是指定順序的最后一個(gè)元素。隊(duì)列查找操作 poll,remove,peek 和 element 訪問(wèn)隊(duì)列頭部元素。優(yōu)先級(jí)隊(duì)列是無(wú)限制的，但具有內(nèi)部 capacity，用于控制用于在隊(duì)列中存儲(chǔ)元素的數(shù)組大小。該類以及迭代器實(shí)現(xiàn)了 Collection、Iterator 接口的所有可選方法。這個(gè)迭代器提供了 iterator() 方法不能保證以任何特定順序遍歷優(yōu)先級(jí)隊(duì)列的元素。如果你需要有序遍歷，考慮使用 Arrays.sort(pq.toArray())。注意這個(gè)實(shí)現(xiàn)不是線程安全的，多線程不應(yīng)該并發(fā)訪問(wèn) PriorityQueue 實(shí)例如果有某個(gè)線程修改了隊(duì)列的話，使用線程安全的類 PriorityBlockingQueue。HashMap
HashMap 是一個(gè)利用哈希表原理來(lái)存儲(chǔ)元素的集合，并且允許空的 key-value 鍵值對(duì)。HashMap 是非線程安全的，也就是說(shuō)在多線程的環(huán)境下，可能會(huì)存在問(wèn)題，而 Hashtable 是線程安全的容器。HashMap 也支持 fail-fast 機(jī)制。HashMap 的實(shí)例有兩個(gè)參數(shù)影響其性能：初始容量 和加載因子?？梢允褂?Collections.synchronizedMap(new HashMap(...)) 來(lái)構(gòu)造一個(gè)線程安全的 HashMap。
TreeMap 類
一個(gè)基于 NavigableMap 實(shí)現(xiàn)的紅黑樹(shù)。這個(gè) map 根據(jù) key 自然排序存儲(chǔ)，或者通過(guò) Comparator 進(jìn)行定制排序。
TreeMap 為 containsKey,get,put 和remove方法提供了 log(n) 的時(shí)間開(kāi)銷。注意這個(gè)實(shí)現(xiàn)不是線程安全的。如果多線程并發(fā)訪問(wèn) TreeMap，并且至少一個(gè)線程修改了 map，必須進(jìn)行外部加鎖。這通常通過(guò)在自然封裝集合的某個(gè)對(duì)象上進(jìn)行同步來(lái)實(shí)現(xiàn)，或者使用 SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...))。這個(gè)實(shí)現(xiàn)持有fail-fast機(jī)制。LinkedHashMap 類
LinkedHashMap 是 Map 接口的哈希表和鏈表的實(shí)現(xiàn)。這個(gè)實(shí)現(xiàn)與 HashMap 不同之處在于它維護(hù)了一個(gè)貫穿其所有條目的雙向鏈表。這個(gè)鏈表定義了遍歷順序，通常是插入 map 中的順序。
它提供一個(gè)特殊的 LinkedHashMap(int,float,boolean) 構(gòu)造器來(lái)創(chuàng)建 LinkedHashMap，其遍歷順序是其最后一次訪問(wèn)的順序?？梢灾貙?xiě) removeEldestEntry(Map.Entry) 方法，以便在將新映射添加到 map 時(shí)強(qiáng)制刪除過(guò)期映射的策略。這個(gè)類提供了所有可選擇的 map 操作，并且允許 null 元素。由于維護(hù)鏈表的額外開(kāi)銷，性能可能會(huì)低于HashMap，有一條除外：遍歷 LinkedHashMap 中的 collection-views 需要與 map.size 成正比，無(wú)論其容量如何。HashMap 的迭代看起來(lái)開(kāi)銷更大，因?yàn)檫€要求時(shí)間與其容量成正比。LinkedHashMap 有兩個(gè)因素影響了它的構(gòu)成：初始容量和加載因子。注意這個(gè)實(shí)現(xiàn)不是線程安全的。如果多線程并發(fā)訪問(wèn)LinkedHashMap，并且至少一個(gè)線程修改了map，必須進(jìn)行外部加鎖。這通常通過(guò)在自然封裝集合的某個(gè)對(duì)象上進(jìn)行同步來(lái)實(shí)現(xiàn) Map m = Collections.synchronizedMap(new LinkedHashMap(...))。這個(gè)實(shí)現(xiàn)持有fail-fast機(jī)制。Hashtable 類
Hashtable 類實(shí)現(xiàn)了一個(gè)哈希表，能夠?qū)㈡I映射到值。任何非空對(duì)象都可以用作鍵或值。
此實(shí)現(xiàn)類支持 fail-fast 機(jī)制與新的集合實(shí)現(xiàn)不同，Hashtable 是線程安全的。如果不需要線程安全的容器，推薦使用 HashMap，如果需要多線程高并發(fā)，推薦使用 ConcurrentHashMap。IdentityHashMap 類
IdentityHashMap 是比較小眾的 Map 實(shí)現(xiàn)了。
這個(gè)類不是一個(gè)通用的 Map 實(shí)現(xiàn)！雖然這個(gè)類實(shí)現(xiàn)了 Map 接口，但它故意違反了 Map 的約定，該約定要求在比較對(duì)象時(shí)使用 equals 方法，此類僅適用于需要引用相等語(yǔ)義的極少數(shù)情況。同 HashMap，IdentityHashMap 也是無(wú)序的，并且該類不是線程安全的，如果要使之線程安全，可以調(diào)用Collections.synchronizedMap(new IdentityHashMap(...))方法來(lái)實(shí)現(xiàn)。支持fail-fast機(jī)制WeakHashMap 類
WeakHashMap 類基于哈希表的 Map 基礎(chǔ)實(shí)現(xiàn)，帶有弱鍵。WeakHashMap 中的 entry 當(dāng)不再使用時(shí)還會(huì)自動(dòng)移除。更準(zhǔn)確的說(shuō)，給定key的映射的存在將不會(huì)阻止 key 被垃圾收集器丟棄。
基于 map 接口，是一種弱鍵相連，WeakHashMap 里面的鍵會(huì)自動(dòng)回收支持 null 值和 null 鍵。fast-fail 機(jī)制不允許重復(fù)WeakHashMap 經(jīng)常用作緩存Collections 類
Collections 不屬于 Java 框架繼承樹(shù)上的內(nèi)容，它屬于單獨(dú)的分支，Collections 是一個(gè)包裝類，它的作用就是為集合框架提供某些功能實(shí)現(xiàn)，此類只包括靜態(tài)方法操作或者返回 collections。
同步包裝
同步包裝器將自動(dòng)同步（線程安全性）添加到任意集合。六個(gè)核心集合接口（Collection，Set，List，Map，SortedSet 和 SortedMap）中的每一個(gè)都有一個(gè)靜態(tài)工廠方法。
publicstatic Collection synchronizedCollection(Collection c);publicstatic Set synchronizedSet(Set s);publicstatic List synchronizedList(List list);publicstatic <K,V> Map<K,V> synchronizedMap(Map<K,V> m);publicstatic SortedSet synchronizedSortedSet(SortedSet s);publicstatic <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);
不可修改的包裝
不可修改的包裝器通過(guò)攔截修改集合的操作并拋出 UnsupportedOperationException，主要用在下面兩個(gè)情景：
構(gòu)建集合后使其不可變。在這種情況下，最好不要去獲取返回 collection 的引用，這樣有利于保證不變性允許某些客戶端以只讀方式訪問(wèn)你的數(shù)據(jù)結(jié)構(gòu)。你保留對(duì)返回的 collection 的引用，但分發(fā)對(duì)包裝器的引用。通過(guò)這種方式，客戶可以查看但不能修改，同時(shí)保持完全訪問(wèn)權(quán)限。這些方法是：
publicstatic Collection unmodifiableCollection(Collection<? extends T> c);publicstatic Set unmodifiableSet(Set<? extends T> s);publicstatic List unmodifiableList(List<? extends T> list);publicstatic <K,V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m);publicstatic SortedSet unmodifiableSortedSet(SortedSet<? extends T> s);publicstatic <K,V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);
線程安全的Collections
Java1.5 并發(fā)包 (java.util.concurrent) 提供了線程安全的 collections 允許遍歷的時(shí)候進(jìn)行修改，通過(guò)設(shè)計(jì)iterator 為 fail-fast 并拋出 ConcurrentModificationException。一些實(shí)現(xiàn)類是CopyOnWriteArrayList，ConcurrentHashMap，CopyOnWriteArraySet
Collections 算法
此類包含用于集合框架算法的方法，例如二進(jìn)制搜索，排序，重排，反向等。
集合實(shí)現(xiàn)類特征圖
下圖匯總了部分集合框架的主要實(shí)現(xiàn)類的特征圖，讓你能有清晰明了看出每個(gè)實(shí)現(xiàn)類之間的差異性
還有一種類型是關(guān)于強(qiáng)引用、弱引用、虛引用的文章，請(qǐng)參考
https://mp.weixin.qq.com/s/ZflBpn2TBzTNv_-G-zZxNg
泛形
在 Jdk1.5 中，提出了一種新的概念，那就是泛型，那么什么是泛型呢？
泛型其實(shí)就是一種參數(shù)化的集合，它限制了你添加進(jìn)集合的類型。泛型的本質(zhì)就是一種參數(shù)化類型。多態(tài)也可以看作是泛型的機(jī)制。一個(gè)類繼承了父類，那么就能通過(guò)它的父類找到對(duì)應(yīng)的子類，但是不能通過(guò)其他類來(lái)找到具體要找的這個(gè)類。泛型的設(shè)計(jì)之處就是希望對(duì)象或方法具有最廣泛的表達(dá)能力。
下面來(lái)看一個(gè)例子說(shuō)明沒(méi)有泛型的用法
List arrayList = new ArrayList();arrayList.add("cxuan");arrayList.add(100);for(int i = 0; i< arrayList.size();i++){ String item = (String)arrayList.get(i); System.out.println("test === ", item);}
這段程序不能正常運(yùn)行，原因是 Integer 類型不能直接強(qiáng)制轉(zhuǎn)換為 String 類型
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
如果我們用泛型進(jìn)行改寫(xiě)后，示例代碼如下
List<String> arrayList = new ArrayList<String>();arrayList.add(100);
這段代碼在編譯期間就會(huì)報(bào)錯(cuò)，編譯器會(huì)在編譯階段就能夠幫我們發(fā)現(xiàn)類似這樣的問(wèn)題。
泛型的使用
泛型的使用有多種方式，下面我們就來(lái)一起探討一下。
用泛型表示類
泛型可以加到類上面，來(lái)表示這個(gè)類的類型
//此處 T 可以隨便寫(xiě)為任意標(biāo)識(shí)，常見(jiàn)的如T、E、K、V等形式的參數(shù)常用于表示泛型publicclassGenericDemo<T>{ //value 這個(gè)成員變量的類型為T,T的類型由外部指定 private T value;publicGenericDemo(T value){this.value = value; }public T getValue(){ //泛型方法getKey的返回值類型為T，T的類型由外部指定return value; }publicvoidsetValue(T value){this.value = value }}
用泛型表示接口
泛型接口與泛型類的定義及使用基本相同。
//定義一個(gè)泛型接口publicinterfaceGenerator<T> {public T next();}
一般泛型接口常用于 生成器(generator) 中，生成器相當(dāng)于對(duì)象工廠，是一種專門用來(lái)創(chuàng)建對(duì)象的類。
泛型方法
可以使用泛型來(lái)表示方法
publicclassGenericMethods{public <T> voidf(T x){ System.out.println(x.getClass().getName()); }}
泛型通配符
List 是泛型類，為了 表示各種泛型 List 的父類，可以使用類型通配符，類型通配符使用問(wèn)號(hào)(?)表示，它的元素類型可以匹配任何類型。例如
publicstaticvoidmain(String[] args){ List<String> name = new ArrayList<String>(); List<Integer> age = new ArrayList<Integer>(); List<Number> number = new ArrayList<Number>(); name.add("cxuan"); age.add(18); number.add(314); generic(name); generic(age); generic(number); }publicstaticvoidgeneric(List<?> data){ System.out.println("Test cxuan :" + data.get(0));}
上界通配符: <? extends ClassType> 該通配符為 ClassType 的所有子類型。它表示的是任何類型都是 ClassType 類型的子類。
下界通配符：<? super ClassType> 該通配符為 ClassType 的所有超類型。它表示的是任何類型的父類都是 ClassType。
反射
反射是 Java 中一個(gè)非常重要同時(shí)也是一個(gè)高級(jí)特性，基本上 Spring 等一系列框架都是基于反射的思想寫(xiě)成的。我們首先來(lái)認(rèn)識(shí)一下什么反射。
Java 反射機(jī)制是在程序的運(yùn)行過(guò)程中，對(duì)于任何一個(gè)類，都能夠知道它的所有屬性和方法；對(duì)于任意一個(gè)對(duì)象，都能夠知道調(diào)用它的任意屬性和方法，這種動(dòng)態(tài)獲取信息以及動(dòng)態(tài)調(diào)用對(duì)象方法的功能稱為java語(yǔ)言的反射機(jī)制。（來(lái)源于百度百科）
Java 反射機(jī)制主要提供了以下這幾個(gè)功能
在運(yùn)行時(shí)判斷任意一個(gè)對(duì)象所屬的類在運(yùn)行時(shí)構(gòu)造任意一個(gè)類的對(duì)象在運(yùn)行時(shí)判斷任意一個(gè)類所有的成員變量和方法在運(yùn)行時(shí)調(diào)用任意一個(gè)對(duì)象的方法這么一看，反射就像是一個(gè)掌控全局的角色，不管你程序怎么運(yùn)行，我都能夠知道你這個(gè)類有哪些屬性和方法，你這個(gè)對(duì)象是由誰(shuí)調(diào)用的，嗯，很屌。
在 Java 中，使用 Java.lang.reflect包實(shí)現(xiàn)了反射機(jī)制。Java.lang.reflect 所設(shè)計(jì)的類如下
下面是一個(gè)簡(jiǎn)單的反射類
publicclassPerson{public String name;// 姓名publicint age;// 年齡publicPerson(){super(); }publicPerson(String name, int age){super();this.name = name;this.age = age; }public String showInfo(){return"name=" + name + ", age=" + age; }}publicclassStudentextendsPersonimplementsStudy{public String className;// 班級(jí)private String address;// 住址publicStudent(){super(); }publicStudent(String name, int age, String className, String address){super(name, age);this.className = className;this.address = address; }publicStudent(String className){this.className = className; }public String toString(){return"姓名：" + name + ",年齡：" + age + ",班級(jí)：" + className + ",住址：" + address; }public String getAddress(){return address; }publicvoidsetAddress(String address){this.address = address; }}publicclassTestRelect{publicstaticvoidmain(String[] args){ Class student = null;try { student = Class.forName("com.cxuan.reflection.Student"); } catch (ClassNotFoundException e) { e.printStackTrace(); }// 獲取對(duì)象的所有公有屬性。 Field[] fields = student.getFields();for (Field f : fields) { System.out.println(f); } System.out.println("---------------------");// 獲取對(duì)象所有屬性，但不包含繼承的。 Field[] declaredFields = student.getDeclaredFields();for (Field df : declaredFields) { System.out.println(df); }// 獲取對(duì)象的所有公共方法 Method[] methods = student.getMethods();for (Method m : methods) { System.out.println(m); } System.out.println("---------------------");// 獲取對(duì)象所有方法，但不包含繼承的 Method[] declaredMethods = student.getDeclaredMethods();for (Method dm : declaredMethods) { System.out.println(dm); }// 獲取對(duì)象所有的公共構(gòu)造方法 Constructor[] constructors = student.getConstructors();for (Constructor c : constructors) { System.out.println(c); } System.out.println("---------------------");// 獲取對(duì)象所有的構(gòu)造方法 Constructor[] declaredConstructors = student.getDeclaredConstructors();for (Constructor dc : declaredConstructors) { System.out.println(dc); } Class c = Class.forName("com.cxuan.reflection.Student"); Student stu1 = (Student) c.newInstance();// 第一種方法，實(shí)例化默認(rèn)構(gòu)造方法，調(diào)用set賦值 stu1.setAddress("河北石家莊"); System.out.println(stu1);// 第二種方法 取得全部的構(gòu)造函數(shù) 使用構(gòu)造函數(shù)賦值 Constructor<Student> constructor = c.getConstructor(String.class, int.class, String.class, String.class); Student student2 = (Student) constructor.newInstance("cxuan", 24, "六班", "石家莊"); System.out.println(student2);/** * 獲取方法并執(zhí)行方法 */ Method show = c.getMethod("showInfo");//獲取showInfo()方法 Object object = show.invoke(stu2);//調(diào)用showInfo()方法 }}
有一些是比較常用的，有一些是我至今都沒(méi)見(jiàn)過(guò)怎么用的，下面進(jìn)行一個(gè)歸類。
與 Java 反射有關(guān)的類主要有
Class 類
在 Java 中，你每定義一個(gè) java class 實(shí)體都會(huì)產(chǎn)生一個(gè) Class 對(duì)象。也就是說(shuō)，當(dāng)我們編寫(xiě)一個(gè)類，編譯完成后，在生成的 .class 文件中，就會(huì)產(chǎn)生一個(gè) Class 對(duì)象，這個(gè) Class 對(duì)象用于表示這個(gè)類的類型信息。Class 中沒(méi)有公共的構(gòu)造器，也就是說(shuō) Class 對(duì)象不能被實(shí)例化。下面來(lái)簡(jiǎn)單看一下 Class 類都包括了哪些方法
toString()
public String toString(){return (isInterface() ? "interface " : (isPrimitive() ? "" : "class ")) + getName();}
toString() 方法能夠?qū)?duì)象轉(zhuǎn)換為字符串，toString() 首先會(huì)判斷 Class 類型是否是接口類型，也就是說(shuō)，普通類和接口都能夠用 Class 對(duì)象來(lái)表示，然后再判斷是否是基本數(shù)據(jù)類型，這里判斷的都是基本數(shù)據(jù)類型和包裝類，還有 void類型。
所有的類型如下
java.lang.Boolean : 代表 boolean 數(shù)據(jù)類型的包裝類java.lang.Character: 代表 char 數(shù)據(jù)類型的包裝類java.lang.Byte: 代表 byte 數(shù)據(jù)類型的包裝類java.lang.Short: 代表 short 數(shù)據(jù)類型的包裝類java.lang.Integer: 代表 int 數(shù)據(jù)類型的包裝類java.lang.Long: 代表 long 數(shù)據(jù)類型的包裝類java.lang.Float: 代表 float 數(shù)據(jù)類型的包裝類java.lang.Double: 代表 double 數(shù)據(jù)類型的包裝類java.lang.Void: 代表 void 數(shù)據(jù)類型的包裝類然后是 getName() 方法，這個(gè)方法返回類的全限定名稱。
如果是引用類型，比如 String.class.getName() -> java.lang.String如果是基本數(shù)據(jù)類型，byte.class.getName() -> byte如果是數(shù)組類型，new Object[3]).getClass().getName() -> [Ljava.lang.ObjecttoGenericString()
這個(gè)方法會(huì)返回類的全限定名稱，而且包括類的修飾符和類型參數(shù)信息。
forName()
根據(jù)類名獲得一個(gè) Class 對(duì)象的引用，這個(gè)方法會(huì)使類對(duì)象進(jìn)行初始化。
例如 Class t = Class.forName("java.lang.Thread") 就能夠初始化一個(gè) Thread 線程對(duì)象
在 Java 中，一共有三種獲取類實(shí)例的方式
Class.forName(java.lang.Thread)Thread.classthread.getClass()newInstance()
創(chuàng)建一個(gè)類的實(shí)例，代表著這個(gè)類的對(duì)象。上面 forName() 方法對(duì)類進(jìn)行初始化，newInstance 方法對(duì)類進(jìn)行實(shí)例化。
getClassLoader()
獲取類加載器對(duì)象。
getTypeParameters()
按照聲明的順序獲取對(duì)象的參數(shù)類型信息。
getPackage()
返回類的包
getInterfaces()
獲得當(dāng)前類實(shí)現(xiàn)的類或是接口，可能是有多個(gè)，所以返回的是 Class 數(shù)組。
Cast
把對(duì)象轉(zhuǎn)換成代表類或是接口的對(duì)象
asSubclass(Class clazz)
把傳遞的類的對(duì)象轉(zhuǎn)換成代表其子類的對(duì)象
getClasses()
返回一個(gè)數(shù)組，數(shù)組中包含該類中所有公共類和接口類的對(duì)象
getDeclaredClasses()
返回一個(gè)數(shù)組，數(shù)組中包含該類中所有類和接口類的對(duì)象
getSimpleName()
獲得類的名字
getFields()
獲得所有公有的屬性對(duì)象
getField(String name)
獲得某個(gè)公有的屬性對(duì)象
getDeclaredField(String name)
獲得某個(gè)屬性對(duì)象
getDeclaredFields()
獲得所有屬性對(duì)象
getAnnotation(Class annotationClass)
返回該類中與參數(shù)類型匹配的公有注解對(duì)象
getAnnotations()
返回該類所有的公有注解對(duì)象
getDeclaredAnnotation(Class annotationClass)
返回該類中與參數(shù)類型匹配的所有注解對(duì)象
getDeclaredAnnotations()
返回該類所有的注解對(duì)象
getConstructor(Class...<?> parameterTypes)
獲得該類中與參數(shù)類型匹配的公有構(gòu)造方法
getConstructors()
獲得該類的所有公有構(gòu)造方法
getDeclaredConstructor(Class...<?> parameterTypes)
獲得該類中與參數(shù)類型匹配的構(gòu)造方法
getDeclaredConstructors()
獲得該類所有構(gòu)造方法
getMethod(String name, Class...<?> parameterTypes)
獲得該類某個(gè)公有的方法
getMethods()
獲得該類所有公有的方法
getDeclaredMethod(String name, Class...<?> parameterTypes)
獲得該類某個(gè)方法
getDeclaredMethods()
獲得該類所有方法
Field 類
Field 類提供類或接口中單獨(dú)字段的信息，以及對(duì)單獨(dú)字段的動(dòng)態(tài)訪問(wèn)。
這里就不再對(duì)具體的方法進(jìn)行介紹了，讀者有興趣可以參考官方 API
這里只介紹幾個(gè)常用的方法
equals(Object obj)
屬性與obj相等則返回true
get(Object obj)
獲得obj中對(duì)應(yīng)的屬性值
set(Object obj, Object value)
設(shè)置obj中對(duì)應(yīng)屬性值
Method 類
invoke(Object obj, Object... args)
傳遞object對(duì)象及參數(shù)調(diào)用該對(duì)象對(duì)應(yīng)的方法
ClassLoader 類
反射中，還有一個(gè)非常重要的類就是 ClassLoader 類，類裝載器是用來(lái)把類(class) 裝載進(jìn) JVM的。ClassLoader 使用的是雙親委托模型來(lái)搜索加載類的，這個(gè)模型也就是雙親委派模型。ClassLoader 的類繼承圖如下
枚舉
枚舉可能是我們使用次數(shù)比較少的特性，在 Java 中，枚舉使用 enum 關(guān)鍵字來(lái)表示，枚舉其實(shí)是一項(xiàng)非常有用的特性，你可以把它理解為具有特定性質(zhì)的類。enum 不僅僅 Java 有，C 和 C++ 也有枚舉的概念。下面是一個(gè)枚舉的例子。
publicenum Family { FATHER, MOTHER, SON, Daughter;}
上面我們創(chuàng)建了一個(gè) Family的枚舉類，它具有 4 個(gè)值，由于枚舉類型都是常量，所以都用大寫(xiě)字母來(lái)表示。那么 enum 創(chuàng)建出來(lái)了，該如何引用呢？
publicclassEnumUse{publicstaticvoidmain(String[] args){ Family s = Family.FATHER; }}
枚舉特性
enum 枚舉這個(gè)類比較有意思，當(dāng)你創(chuàng)建完 enum 后，編譯器會(huì)自動(dòng)為你的 enum 添加 toString() 方法，能夠讓你方便的顯示 enum 實(shí)例的具體名字是什么。除了 toString() 方法外，編譯器還會(huì)添加 ordinal() 方法，這個(gè)方法用來(lái)表示 enum 常量的聲明順序，以及 values() 方法顯示順序的值。
publicstaticvoidmain(String[] args){for(Family family : Family.values()){ System.out.println(family + ", ordinal" + family.ordinal()); }}
enum 可以進(jìn)行靜態(tài)導(dǎo)入包，靜態(tài)導(dǎo)入包可以做到不用輸入 枚舉類名.常量，可以直接使用常量，神奇嗎? 使用 ennum 和 static 關(guān)鍵字可以做到靜態(tài)導(dǎo)入包
上面代碼導(dǎo)入的是 Family 中所有的常量，也可以單獨(dú)指定常量。
枚舉和普通類一樣
枚舉就和普通類一樣，除了枚舉中能夠方便快捷的定義常量，我們?nèi)粘ｉ_(kāi)發(fā)使用的 public static final xxx 其實(shí)都可以用枚舉來(lái)定義。在枚舉中也能夠定義屬性和方法，千萬(wàn)不要把它看作是異類，它和萬(wàn)千的類一樣。
publicenum OrdinalEnum { WEST("live in west"), EAST("live in east"), SOUTH("live in south"), NORTH("live in north"); String description; OrdinalEnum(String description){this.description = description; }public String getDescription(){return description; }publicvoidsetDescription(String description){this.description = description; }publicstaticvoidmain(String[] args){for(OrdinalEnum ordinalEnum : OrdinalEnum.values()){ System.out.println(ordinalEnum.getDescription()); } }}
一般 switch 可以和 enum 一起連用，來(lái)構(gòu)造一個(gè)小型的狀態(tài)轉(zhuǎn)換機(jī)。
enum Signal { GREEN, YELLOW, RED}publicclassTrafficLight{ Signal color = Signal.RED;publicvoidchange(){switch (color) {case RED: color = Signal.GREEN;break;case YELLOW: color = Signal.RED;break;case GREEN: color = Signal.YELLOW;break; } }}
是不是代碼頓時(shí)覺(jué)得優(yōu)雅整潔了些許呢？
枚舉神秘之處
在 Java 中，萬(wàn)事萬(wàn)物都是對(duì)象，enum 雖然是個(gè)關(guān)鍵字，但是它卻隱式的繼承于 Enum 類。我們來(lái)看一下 Enum 類，此類位于 java.lang 包下，可以自動(dòng)引用。
此類的屬性和方法都比較少。你會(huì)發(fā)現(xiàn)這個(gè)類中沒(méi)有我們的 values 方法。前面剛說(shuō)到，values() 方法是你使用枚舉時(shí)被編譯器添加進(jìn)來(lái)的 static 方法。可以使用反射來(lái)驗(yàn)證一下。
除此之外，enum 還和 Class 類有交集，在 Class 類中有三個(gè)關(guān)于 Enum 的方法
前面兩個(gè)方法用于獲取 enum 常量，isEnum 用于判斷是否是枚舉類型的。
枚舉類
除了 Enum 外，還需要知道兩個(gè)關(guān)于枚舉的工具類，一個(gè)是 EnumSet ，一個(gè)是 EnumMap
EnumSet 和 EnumMap
EnumSet 是 JDK1.5 引入的，EnumSet 的設(shè)計(jì)充分考慮到了速度因素，使用 EnumSet 可以作為 Enum 的替代者，因?yàn)樗男时容^高。
EnumMap 是一種特殊的 Map，它要求其中的 key 鍵值是來(lái)自一個(gè) enum。因?yàn)?EnumMap 速度也很快，我們可以使用 EnumMap 作為 key 的快速查找。
總的來(lái)說(shuō)，枚舉的使用不是很復(fù)雜，它也是 Java 中很小的一塊功能，但有時(shí)卻能夠因?yàn)檫@一個(gè)小技巧，能夠讓你的代碼變得優(yōu)雅和整潔。
I/O
創(chuàng)建一個(gè)良好的 I/O 程序是非常復(fù)雜的。JDK 開(kāi)發(fā)人員編寫(xiě)了大量的類只為了能夠創(chuàng)建一個(gè)良好的工具包，想必編寫(xiě) I/O 工具包很費(fèi)勁吧。
IO 類設(shè)計(jì)出來(lái)，肯定是為了解決 IO 相關(guān)操作的，最常見(jiàn)的 I/O 讀寫(xiě)就是網(wǎng)絡(luò)、磁盤等。在 Java 中，對(duì)文件的操作是一個(gè)典型的 I/O 操作。下面我們就對(duì) I/O 進(jìn)行一個(gè)分類。
I/O 還可以根據(jù)操作對(duì)象來(lái)進(jìn)行區(qū)分：主要分為
除此之外，I/O 中還有其他比較重要的類
File 類
File 類是對(duì)文件系統(tǒng)中文件以及文件夾進(jìn)行操作的類，可以通過(guò)面向?qū)ο蟮乃枷氩僮魑募臀募A，是不是很神奇？
文件創(chuàng)建操作如下，主要涉及 文件創(chuàng)建、刪除文件、獲取文件描述符等
classFileDemo{publicstaticvoidmain(String[] args){ File file = new File("D:\\file.txt");try{ f.createNewFile(); // 創(chuàng)建一個(gè)文件// File類的兩個(gè)常量//路徑分隔符(與系統(tǒng)有關(guān)的）<windows里面是 ; linux里面是 ： > System.out.println(File.pathSeparator); // ;//與系統(tǒng)有關(guān)的路徑名稱分隔符<windows里面是 \ linux里面是/ > System.out.println(File.separator); // \// 刪除文件/* File file = new File(fileName); if(f.exists()){ f.delete(); }else{ System.out.println("文件不存在"); } */ }catch (Exception e) { e.printStackTrace(); } }}
也可以對(duì)文件夾進(jìn)行操作
classFileDemo{publicstaticvoidmain(String[] args){ String fileName = "D:"+ File.separator + "filepackage"; File file = new File(fileName); f.mkdir();// 列出所有文件/* String[] str = file.list(); for (int i = 0; i < str.length; i++) { System.out.println(str[i]); } */// 使用 file.listFiles(); 列出所有文件，包括隱藏文件// 使用 file.isDirectory() 判斷指定路徑是否是目錄 }}
上面只是舉出來(lái)了兩個(gè)簡(jiǎn)單的示例，實(shí)際上，還有一些其他對(duì)文件的操作沒(méi)有使用。比如創(chuàng)建文件，就可以使用三種方式來(lái)創(chuàng)建
File(String directoryPath);File(String directoryPath, String filename);File(File dirObj, String filename);
directoryPath 是文件的路徑名，filename 是文件名，dirObj 是一個(gè) File 對(duì)象。例如
File file = new File("D:\\java\\file1.txt"); //雙\\是轉(zhuǎn)義System.out.println(file);File file2 = new File("D:\\java","file2.txt");//父路徑、子路徑--可以適用于多個(gè)文件的！System.out.println(file2);File parent = new File("D:\\java");File file3 = new File(parent,"file3.txt");//File類的父路徑、子路徑System.out.println(file3);
現(xiàn)在對(duì) File 類進(jìn)行總結(jié)
基礎(chǔ) IO 類和相關(guān)方法
雖然. IO 類有很多，但是最基本的是四個(gè)抽象類，InputStream、OutputStream、Reader、Writer。最基本的方法也就是 read() 和 write() 方法，其他流都是上面這四類流的子類，方法也是通過(guò)這兩類方法衍生而成的。而且大部分的 IO 源碼都是 native 標(biāo)志的，也就是說(shuō)源碼都是 C/C++ 寫(xiě)的。這里我們先來(lái)認(rèn)識(shí)一下這些流類及其方法
InputStream
InputStream 是一個(gè)定義了 Java 流式字節(jié)輸入模式的抽象類。該類的所有方法在出錯(cuò)條件下引發(fā)一個(gè)IOException 異常。它的主要方法定義如下
OutputStream
OutputStream 是定義了流式字節(jié)輸出模式的抽象類。該類的所有方法返回一個(gè)void 值并且在出錯(cuò)情況下引發(fā)一個(gè)IOException異常。它的主要方法定義如下
Reader 類
Reader 是 Java 定義的流式字符輸入模式的抽象類。類中的方法在出錯(cuò)時(shí)引發(fā) IOException 異常。
Writer 類
Writer 是定義流式字符輸出的抽象類。所有該類的方法都返回一個(gè) void 值并在出錯(cuò)條件下引發(fā) IOException 異常
InputStream 及其子類
FileInputStream 文件輸入流：FileInputStream 類創(chuàng)建一個(gè)能從文件讀取字節(jié)的 InputStream 類
ByteArrayInputStream 字節(jié)數(shù)組輸入流：把內(nèi)存中的一個(gè)緩沖區(qū)作為 InputStream 使用
PipedInputStream 管道輸入流：實(shí)現(xiàn)了pipe 管道的概念，主要在線程中使用
SequenceInputStream 順序輸入流：把多個(gè) InputStream 合并為一個(gè) InputStream
FilterOutputStream 過(guò)濾輸入流：其他輸入流的包裝。
ObjectInputStream 反序列化輸入流：將之前使用 ObjectOutputStream 序列化的原始數(shù)據(jù)恢復(fù)為對(duì)象，以流的方式讀取對(duì)象
**DataInputStream ** : 數(shù)據(jù)輸入流允許應(yīng)用程序以與機(jī)器無(wú)關(guān)方式從底層輸入流中讀取基本 Java 數(shù)據(jù)類型。
PushbackInputStream 推回輸入流：緩沖的一個(gè)新穎的用法是實(shí)現(xiàn)推回 （pushback） 。Pushback 用于輸入流允許字節(jié)被讀取然后返回到流。
OutputStream 及其子類
FileOutputStream 文件輸出流：該類實(shí)現(xiàn)了一個(gè)輸出流，其數(shù)據(jù)寫(xiě)入文件。
ByteArrayOutputStream 字節(jié)數(shù)組輸出流：該類實(shí)現(xiàn)了一個(gè)輸出流，其數(shù)據(jù)被寫(xiě)入由 byte 數(shù)組充當(dāng)?shù)木彌_區(qū)，緩沖區(qū)會(huì)隨著數(shù)據(jù)的不斷寫(xiě)入而自動(dòng)增長(zhǎng)。
PipedOutputStream 管道輸出流：管道的輸出流，是管道的發(fā)送端。
ObjectOutputStream 基本類型輸出流：該類將實(shí)現(xiàn)了序列化的對(duì)象序列化后寫(xiě)入指定地方。
FilterOutputStream 過(guò)濾輸出流：其他輸出流的包裝。
PrintStream 打印流通過(guò) PrintStream 可以將文字打印到文件或者網(wǎng)絡(luò)中去。
DataOutputStream : 數(shù)據(jù)輸出流允許應(yīng)用程序以與機(jī)器無(wú)關(guān)方式向底層輸出流中寫(xiě)入基本 Java 數(shù)據(jù)類型。
Reader 及其子類
FileReader 文件字符輸入流：把文件轉(zhuǎn)換為字符流讀入
CharArrayReader 字符數(shù)組輸入流：是一個(gè)把字符數(shù)組作為源的輸入流的實(shí)現(xiàn)
BufferedReader 緩沖區(qū)輸入流：BufferedReader 類從字符輸入流中讀取文本并緩沖字符，以便有效地讀取字符，數(shù)組和行
PushbackReader: PushbackReader 類允許一個(gè)或多個(gè)字符被送回輸入流。
PipedReader 管道輸入流：主要用途也是在線程間通訊，不過(guò)這個(gè)可以用來(lái)傳輸字符
Writer 及其子類
FileWriter 字符輸出流：FileWriter 創(chuàng)建一個(gè)可以寫(xiě)文件的 Writer 類。
CharArrayWriter 字符數(shù)組輸出流：CharArrayWriter 實(shí)現(xiàn)了以數(shù)組作為目標(biāo)的輸出流。
BufferedWriter 緩沖區(qū)輸出流：BufferedWriter是一個(gè)增加了flush( ) 方法的Writer。flush( )方法可以用來(lái)確保數(shù)據(jù)緩沖器確實(shí)被寫(xiě)到實(shí)際的輸出流。
PrintWriter ：PrintWriter 本質(zhì)上是 PrintStream 的字符形式的版本。
PipedWriter 管道輸出流：主要用途也是在線程間通訊，不過(guò)這個(gè)可以用來(lái)傳輸字符
Java 的輸入輸出的流式接口為復(fù)雜而繁重的任務(wù)提供了一個(gè)簡(jiǎn)潔的抽象。過(guò)濾流類的組合允許你動(dòng)態(tài)建立客戶端流式接口來(lái)配合數(shù)據(jù)傳輸要求。繼承高級(jí)流類 InputStream、InputStreamReader、 Reader 和 Writer 類的 Java 程序在將來(lái) （即使創(chuàng)建了新的和改進(jìn)的具體類）也能得到合理運(yùn)用。
注解
Java 注解（Annotation） 又稱為元數(shù)據(jù) ，它為我們?cè)诖a中添加信息提供了一種形式化的方法。它是 JDK1.5 引入的，Java 定義了一套注解，共有 7 個(gè)，3 個(gè)在 java.lang 中，剩下 4 個(gè)在 java.lang.annotation 中。
作用在代碼中的注解有三個(gè)，它們分別是
@Override：重寫(xiě)標(biāo)記，一般用在子類繼承父類后，標(biāo)注在重寫(xiě)過(guò)后的子類方法上。如果發(fā)現(xiàn)其父類，或者是引用的接口中并沒(méi)有該方法時(shí)，會(huì)報(bào)編譯錯(cuò)誤。@Deprecated ：用此注解注釋的代碼已經(jīng)過(guò)時(shí)，不再推薦使用@SuppressWarnings：這個(gè)注解起到忽略編譯器的警告作用元注解有四個(gè)，元注解就是用來(lái)標(biāo)志注解的注解。它們分別是
@Retention: 標(biāo)識(shí)如何存儲(chǔ)，是只在代碼中，還是編入class文件中，或者是在運(yùn)行時(shí)可以通過(guò)反射訪問(wèn)。RetentionPolicy.SOURCE：注解只保留在源文件，當(dāng) Java 文件編譯成class文件的時(shí)候，注解被遺棄；
RetentionPolicy.CLASS：注解被保留到 class 文件，但 jvm 加載 class 文件時(shí)候被遺棄，這是默認(rèn)的生命周期；
RetentionPolicy.RUNTIME：注解不僅被保存到 class 文件中，jvm 加載 class 文件之后，仍然存在；
@Documented: 標(biāo)記這些注解是否包含在 JavaDoc 中。@Target：標(biāo)記這個(gè)注解說(shuō)明了 Annotation 所修飾的對(duì)象范圍，Annotation 可被用于 packages、types（類、接口、枚舉、Annotation類型）、類型成員（方法、構(gòu)造方法、成員變量、枚舉值）、方法參數(shù)和本地變量（如循環(huán)變量、catch參數(shù)）。取值如下publicenum ElementType {TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER, TYPE_USE
@Inherited ：標(biāo)記這個(gè)注解是繼承于哪個(gè)注解類的。從 JDK1.7 開(kāi)始，又添加了三個(gè)額外的注解，它們分別是
@SafeVarargs ：在聲明可變參數(shù)的構(gòu)造函數(shù)或方法時(shí)，Java 編譯器會(huì)報(bào) unchecked 警告。使用 @SafeVarargs 可以忽略這些警告@FunctionalInterface: 表明這個(gè)方法是一個(gè)函數(shù)式接口@Repeatable：標(biāo)識(shí)某注解可以在同一個(gè)聲明上使用多次。注意：注解是不支持繼承的。
關(guān)于 null 的幾種處理方式
對(duì)于 Java 程序員來(lái)說(shuō)，空指針一直是惱人的問(wèn)題，我們?cè)陂_(kāi)發(fā)中經(jīng)常會(huì)受到 NullPointerException 的蹂躪和壁咚。Java 的發(fā)明者也承認(rèn)這是一個(gè)巨大的設(shè)計(jì)錯(cuò)誤。
那么關(guān)于 null ，你應(yīng)該知道下面這幾件事情來(lái)有效的了解 null ，從而避免很多由 null 引起的錯(cuò)誤。
null 是大小寫(xiě)敏感
首先，null 是 Java 中的關(guān)鍵字，像是 public、static、final。它是大小寫(xiě)敏感的，你不能將 null 寫(xiě)成 Null 或 NULL，編輯器將不能識(shí)別它們?nèi)缓髨?bào)錯(cuò)。
這個(gè)問(wèn)題已經(jīng)幾乎不會(huì)出現(xiàn)，因?yàn)?eclipse 和 Idea 編譯器已經(jīng)給出了編譯器提示，所以你不用考慮這個(gè)問(wèn)題。
null 是任何引用類型的初始值
null 是所有引用類型的默認(rèn)值，Java 中的任何引用變量都將null作為默認(rèn)值，也就是說(shuō)所有 Object 類下的引用類型默認(rèn)值都是 null。這對(duì)所有的引用變量都適用。就像是基本類型的默認(rèn)值一樣，例如 int 的默認(rèn)值是 0，boolean 的默認(rèn)值是 false。
下面是基本數(shù)據(jù)類型的初始值
null 只是一種特殊的值
null 既不是對(duì)象也不是一種類型，它僅是一種特殊的值，你可以將它賦予任何類型，你可以將 null 轉(zhuǎn)換為任何類型
publicstaticvoidmain(String[] args){ String str = null; Integer itr = null; Double dou = null; Integer integer = (Integer) null; String string = (String)null; System.out.println("integer = " + integer); System.out.println("string = " + string);}
你可以看到在編譯期和運(yùn)行期內(nèi)，將 null 轉(zhuǎn)換成任何的引用類型都是可行的，并且不會(huì)拋出空指針異常。
null 只能賦值給引用變量，不能賦值給基本類型變量。
持有 null 的包裝類在進(jìn)行自動(dòng)拆箱的時(shí)候，不能完成轉(zhuǎn)換，會(huì)拋出空指針異常，并且 null 也不能和基本數(shù)據(jù)類型進(jìn)行對(duì)比
publicstaticvoidmain(String[] args){int i = 0; Integer itr = null; System.out.println(itr == i);}
使用了帶有 null 值的引用類型變量，instanceof 操作會(huì)返回 false
publicstaticvoidmain(String[] args){ Integer isNull = null;// instanceof = isInstance 方法if(isNull instanceof Integer){ System.out.println("isNull is instanceof Integer"); }else{ System.out.println("isNull is not instanceof Integer"); }}
這是 instanceof 操作符一個(gè)很重要的特性，使得對(duì)類型強(qiáng)制轉(zhuǎn)換檢查很有用
靜態(tài)變量為 null 調(diào)用靜態(tài)方法不會(huì)拋出 NullPointerException。因?yàn)殪o態(tài)方法使用了靜態(tài)綁定。
使用 Null-Safe 方法
你應(yīng)該使用 null-safe 安全的方法，java 類庫(kù)中有很多工具類都提供了靜態(tài)方法，例如基本數(shù)據(jù)類型的包裝類，Integer , Double 等。例如
publicclassNullSafeMethod{privatestatic String number;publicstaticvoidmain(String[] args){ String s = String.valueOf(number); String string = number.toString(); System.out.println("s = " + s); System.out.println("string = " + string); }}
number 沒(méi)有賦值，所以默認(rèn)為null，使用String.value(number) 靜態(tài)方法沒(méi)有拋出空指針異常，但是使用 toString()卻拋出了空指針異常。所以盡量使用對(duì)象的靜態(tài)方法。
null 判斷
你可以使用 == 或者 != 操作來(lái)比較 null 值，但是不能使用其他算法或者邏輯操作，例如小于或者大于。跟SQL不一樣，在Java中 null == null 將返回 true，如下所示：
publicclassCompareNull{privatestatic String str1;privatestatic String str2;publicstaticvoidmain(String[] args){ System.out.println("str1 == str2 ? " + str1 == str2); System.out.println(null == null); }}
關(guān)于思維導(dǎo)圖
我把一些常用的 Java 工具包的思維導(dǎo)圖做了匯總，方便讀者查閱。
Java.IO
Java.lang
Java.math
Java.net
評(píng)論列表
有情感誤區(qū)能找情感機(jī)構(gòu)有專業(yè)的老師指導(dǎo)，心情也好多了
求助
可以幫助復(fù)合嗎？
求助