先來(lái)看一下本篇文章的思維導(dǎo)圖吧，我會(huì)圍繞下面這些內(nèi)容進(jìn)行講解。

下面開(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 是一門(mén)面向?qū)ο蟮木幊陶Z(yǔ)言

什么是面向?qū)ο?#xff1f;面向?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)⒀?#xff0c;吃飯，去學(xué)校。一般是順序性的完成一系列動(dòng)作。

class?student?{void?student_wakeUp(){...}void?student_cloth(){...}void?student_wash(){...}void?student_eating(){...}void?student_gotoSchool(){...} }

而面向?qū)ο罂梢园褜W(xué)生進(jìn)行抽象，所以這個(gè)例子就會(huì)變?yōu)?/p> class?student(){void?wakeUp(){...}void?cloth(){...}void?wash(){...}void?eating(){...}void?gotoSchool(){...} }

可以不用嚴(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)越火的一門(mén)語(yǔ)言。這是特點(diǎn)三。

• Java 是一門(mén)靜態(tài)語(yǔ)言，靜態(tài)語(yǔ)言指的就是在編譯期間就能夠知道數(shù)據(jù)類(lèi)型的語(yǔ)言，在運(yùn)行前就能夠檢查類(lèi)型的正確性，一旦類(lèi)型確定后就不能再更改，比如下面這個(gè)例子。

public?void?foo()?{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)有任何特定的情況需要指定變量的類(lèi)型，在運(yùn)行時(shí)確定的數(shù)據(jù)類(lèi)型。比如有**Lisp, Perl, Python、Ruby、JavaScript **等。

從設(shè)計(jì)的角度上來(lái)說(shuō)，所有的語(yǔ)言都是設(shè)計(jì)用來(lái)把人類(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)多線(xiàn)程

Java 是一門(mén)高級(jí)語(yǔ)言，高級(jí)語(yǔ)言會(huì)對(duì)用戶(hù)屏蔽很多底層實(shí)現(xiàn)細(xì)節(jié)。比如 Java 是如何實(shí)現(xiàn)多線(xiàn)程的。從操作系統(tǒng)的角度來(lái)說(shuō)，實(shí)現(xiàn)多線(xiàn)程的方式主要有下面這幾種

在用戶(hù)空間中實(shí)現(xiàn)多線(xiàn)程

在內(nèi)核空間中實(shí)現(xiàn)多線(xiàn)程

在用戶(hù)和內(nèi)核空間中混合實(shí)現(xiàn)線(xiàn)程

而我認(rèn)為 Java 應(yīng)該是在?用戶(hù)空間?實(shí)現(xiàn)的多線(xiàn)程，內(nèi)核是感知不到 Java 存在多線(xiàn)程機(jī)制的。這是特點(diǎn)六。

• Java 具有高性能

我們編寫(xiě)的代碼，經(jīng)過(guò) javac 編譯器編譯稱(chēng)為?字節(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)類(lèi)型機(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)用編程的類(lèi)庫(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）稱(chēng)為 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 的核心類(lèi)庫(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ù)類(lèi)型

在 Java 中，數(shù)據(jù)類(lèi)型只有四類(lèi)八種

• 整數(shù)型：byte、short、int、long

byte 也就是字節(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ù)類(lèi)型：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 類(lèi)型是一個(gè)單一的 16 位 Unicode 字符，最小值是?\u0000 (也就是 0 )，最大值是?\uffff (即為 65535)，char 數(shù)據(jù)類(lèi)型可以存儲(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 的字符串表示方式

• 類(lèi)名：對(duì)于所有的類(lèi)來(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ù)、一些類(lèi)型的賦值語(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)算符用于程序中的變量之間，變量和自變量之間以及其他類(lèi)型的信息之間的比較。

比較運(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ù)基本類(lèi)型中的每個(gè)比特位，也就是二進(jìn)制位。按位操作符會(huì)對(duì)兩個(gè)參數(shù)中對(duì)應(yīng)的位執(zhí)行布爾代數(shù)運(yùn)算，并最終生成一個(gè)結(jié)果。

如果進(jìn)行比較的雙方是數(shù)字的話(huà)，那么進(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)算符是類(lèi)似?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){return?true; } return?false;

if...else 條件語(yǔ)句

if 語(yǔ)句還可以與 else 連用，通常表現(xiàn)為?如果滿(mǎ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"); }?else?if?(x?>?30)?{System.out.println("x的值大于30但小于60"); }?else?if?(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)?{case?1:System.out.println("Monday");break;case?2:System.out.println("Tuesday");break;case?3:System.out.println("Wednesday");break;case?4:System.out.println("Thursday");break;case?5:System.out.println("Friday");break;case?6:System.out.println("Saturday");break;case?7:System.out.println("Sunday");break;default:System.out.println("No?Else");break; }

循環(huán)語(yǔ)句

循環(huán)語(yǔ)句就是在滿(mǎn)足一定的條件下反復(fù)執(zhí)行某一表達(dá)式的操作，直到滿(mǎn)足循環(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è)變量，但它們必須具有相同的類(lèi)型

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ǔ)句。

public?void?getName()?{return?name; }

面向?qū)ο?/h2>

下面我們來(lái)探討面向?qū)ο蟮乃枷?#xff0c;面向?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 程序。

類(lèi)也是一種對(duì)象

現(xiàn)在我們來(lái)認(rèn)識(shí)一個(gè)面向?qū)ο蟮男碌母拍?--- 類(lèi)，什么是類(lèi)，它就相當(dāng)于是一系列對(duì)象的抽象，就比如書(shū)籍一樣，類(lèi)相當(dāng)于是書(shū)的封面，大多數(shù)面向?qū)ο蟮恼Z(yǔ)言都使用?class?來(lái)定義類(lèi)，它告訴你它里面定義的對(duì)象都是什么樣的，我們一般使用下面來(lái)定義類(lèi)

class?ClassName?{//?body; }

代碼段中涉及一個(gè)新的概念?//?，這個(gè)我們后面會(huì)說(shuō)。上面，你聲明了一個(gè) class 類(lèi)，現(xiàn)在，你就可以使用 new 來(lái)創(chuàng)建這個(gè)對(duì)象

ClassName?classname?=?new?ClassName();

一般，類(lèi)的命名遵循駝峰原則，它的定義如下

“

駱駝式命名法（Camel-Case）又稱(chēng)駝峰式命名法，是電腦程式編寫(xiě)時(shí)的一套命名規(guī)則（慣例）。正如它的名稱(chēng) CamelCase 所表示的那樣，是指混合使用大小寫(xiě)字母來(lái)構(gòu)成變量和函數(shù)的名字。程序員們?yōu)榱俗约旱拇a能更容易的在同行之間交流，所以多采取統(tǒng)一的可讀性比較好的命名方式。

對(duì)象的創(chuàng)建

在 Java 中，萬(wàn)事萬(wàn)物都是對(duì)象。這句話(huà)相信你一定不陌生，盡管一切都看作是對(duì)象，但是你操縱的卻是一個(gè)對(duì)象的?引用(reference)。在這里有一個(gè)很形象的比喻：你可以把車(chē)鑰匙和車(chē)看作是一組對(duì)象引用和對(duì)象的組合。當(dāng)你想要開(kāi)車(chē)的時(shí)候，你首先需要拿出車(chē)鑰匙點(diǎn)擊開(kāi)鎖的選項(xiàng)，停車(chē)時(shí)，你需要點(diǎn)擊加鎖來(lái)鎖車(chē)。車(chē)鑰匙相當(dāng)于就是引用，車(chē)就是對(duì)象，由車(chē)鑰匙來(lái)驅(qū)動(dòng)車(chē)的加鎖和開(kāi)鎖。并且，即使沒(méi)有車(chē)的存在，車(chē)鑰匙也是一個(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ì)象就好了。祝你下輩子幸福。

屬性和方法

類(lèi)一個(gè)最基本的要素就是有屬性和方法。

屬性也被稱(chēng)為字段，它是類(lèi)的重要組成部分，屬性可以是任意類(lèi)型的對(duì)象，也可以是基本數(shù)據(jù)類(lèi)型。例如下

class?A{int?a;Apple?apple; }

類(lèi)中還應(yīng)該包括方法，方法表示的是?做某些事情的方式。方法其實(shí)就是函數(shù)，只不過(guò) Java 習(xí)慣把函數(shù)稱(chēng)為方法。這種叫法也體現(xiàn)了面向?qū)ο蟮母拍睢?/p>

方法的基本組成包括?方法名稱(chēng)、參數(shù)、返回值和方法體， 下面是它的示例

public?int?getResult(){//?...return?1; }

其中，getResult?就是方法名稱(chēng)、()?里面表示方法接收的參數(shù)、return?表示方法的返回值，注意：方法的返回值必須和方法的參數(shù)類(lèi)型保持一致。有一種特殊的參數(shù)類(lèi)型 ---?void?表示方法無(wú)返回值。{}?包含的代碼段被稱(chēng)為方法體。

構(gòu)造方法

在 Java 中，有一種特殊的方法被稱(chēng)為?構(gòu)造方法，也被稱(chēng)為構(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ù)類(lèi)型和返回值，它的名稱(chēng)要和類(lèi)名保持一致，并且構(gòu)造方法可以有多個(gè)，下面是一個(gè)構(gòu)造方法的示例

class?Apple?{int?sum;String?color;public?Apple(){}public?Apple(int?sum){}public?Apple(String?color){}public?Apple(int?sum,String?color){}}

上面定義了一個(gè) Apple 類(lèi)，你會(huì)發(fā)現(xiàn)這個(gè) Apple 類(lèi)沒(méi)有參數(shù)類(lèi)型和返回值，并且有多個(gè)以 Apple 同名的方法，而且各個(gè) Apple 的參數(shù)列表都不一樣，這其實(shí)是一種多態(tài)的體現(xiàn)，我們后面會(huì)說(shuō)。在定義完成構(gòu)造方法后，我們就能夠創(chuàng)建 Apple 對(duì)象了。

class?createApple?{public?static?void?main(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)造方法被稱(chēng)為默認(rèn)的構(gòu)造方法，也就是

Apple?apple1?=?new?Apple();

如果類(lèi)中沒(méi)有定義任何構(gòu)造方法，那么 JVM 會(huì)為你自動(dòng)生成一個(gè)構(gòu)造方法，如下

class?Apple?{int?sum;String?color;}class?createApple?{public?static?void?main(String[]?args)?{Apple?apple1?=?new?Apple();} }

上面代碼不會(huì)發(fā)生編譯錯(cuò)誤，因?yàn)?Apple 對(duì)象包含了一個(gè)默認(rèn)的構(gòu)造方法。

默認(rèn)的構(gòu)造方法也被稱(chēng)為默認(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è)很重要的概念是方法的重載，它是類(lèi)名的不同表現(xiàn)形式。我們上面說(shuō)到了構(gòu)造函數(shù)，其實(shí)構(gòu)造函數(shù)也是重載的一種。另外一種就是方法的重載

public?class?Apple?{int?sum;String?color;public?Apple(){}public?Apple(int?sum){}public?int?getApple(int?num){return?1;}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ù)的類(lèi)型、順序、參數(shù)數(shù)量等，滿(mǎn)足一種一個(gè)因素就構(gòu)成了重載的必要條件。

請(qǐng)記住下面重載的條件

• 方法名稱(chēng)必須相同。

• 參數(shù)列表必須不同（個(gè)數(shù)不同、或類(lèi)型不同、參數(shù)類(lèi)型排列順序不同等）。

• 方法的返回類(lèi)型可以相同也可以不相同。

• 僅僅返回類(lèi)型不同不足以成為方法的重載。

• 重載是發(fā)生在編譯時(shí)的，因?yàn)榫幾g器可以根據(jù)參數(shù)的類(lèi)型來(lái)選擇使用哪個(gè)方法。

方法的重寫(xiě)

方法的重寫(xiě)與重載雖然名字很相似，但卻完全是不同的東西。方法重寫(xiě)的描述是對(duì)子類(lèi)和父類(lèi)之間的。而重載指的是同一類(lèi)中的。例如如下代碼

class?Fruit?{public?void?eat(){System.out.printl('eat?fruit');} }class?Apple?extends?Fruit{@Overridepublic?void?eat(){System.out.printl('eat?apple');} }

上面這段代碼描述的就是重寫(xiě)的代碼，你可以看到，子類(lèi) Apple 中的方法和父類(lèi) Fruit 中的方法同名，所以，我們能夠推斷出重寫(xiě)的原則

• 重寫(xiě)的方法必須要和父類(lèi)保持一致，包括返回值類(lèi)型,方法名,參數(shù)列表?也都一樣。

• 重寫(xiě)的方法可以使用?@Override?注解來(lái)標(biāo)識(shí)

• 子類(lèi)中重寫(xiě)方法的訪(fǎng)問(wèn)權(quán)限不能低于父類(lèi)中方法的訪(fǎng)問(wèn)權(quán)限。

初始化

類(lèi)的初始化

上面我們創(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)行的初始化，也就是如下這段代碼

class?Car{public?Car(){} }

這個(gè)無(wú)參數(shù)的構(gòu)造函數(shù)可以隱藏，由 JVM 自動(dòng)添加。也就是說(shuō)，構(gòu)造函數(shù)能夠確保類(lèi)的初始化。

成員初始化

Java 會(huì)盡量保證每個(gè)變量在使用前都會(huì)獲得初始化，初始化涉及兩種初始化。

• 一種是編譯器默認(rèn)指定的字段初始化，基本數(shù)據(jù)類(lèi)型的初始化

• 一種是其他對(duì)象類(lèi)型的初始化，String 也是一種對(duì)象，對(duì)象的初始值都為?null?，其中也包括基本類(lèi)型的包裝類(lèi)。

• 一種是指定數(shù)值的初始化，例如

int?a?=?11

也就是說(shuō)， 指定 a 的初始化值不是 0 ，而是 11。其他基本類(lèi)型和對(duì)象類(lèi)型也是一樣的。

構(gòu)造器初始化

可以利用構(gòu)造器來(lái)對(duì)某些方法和某些動(dòng)作進(jìn)行初始化，確定初始值，例如

public?class?Counter{int?i;public?Counter(){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ù)：類(lèi)名相同的方法

• 方法：普通方法

public?class?LifeCycle?{//?靜態(tài)屬性private?static?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ù)public?LifeCycle()?{System.out.println("構(gòu)造函數(shù)初始化");}public?static?String?getStaticField()?{String?statiFiled?=?"Static?Field?Initial";return?statiFiled;}public?static?String?getField()?{String?filed?=?"Field?Initial";return?filed;}???//?主函數(shù)public?static?void?main(String[]?argc)?{new?LifeCycle();} }

這段代碼的執(zhí)行結(jié)果就反應(yīng)了它的初始化順序

靜態(tài)屬性初始化 靜態(tài)方法塊初始化 普通屬性初始化 普通方法塊初始化 構(gòu)造函數(shù)初始化

數(shù)組初始化

數(shù)組是相同類(lèi)型的、用一個(gè)標(biāo)識(shí)符名稱(chēng)封裝到一起的一個(gè)對(duì)象序列或基本類(lèi)型數(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ù)組冷門(mén)的用法就是可變參數(shù)?，可變參數(shù)的定義如下

public?int?add(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ì)象的銷(xiāo)毀

雖然 Java 語(yǔ)言是基于 C++ 的，但是它和 C/C++ 一個(gè)重要的特征就是不需要手動(dòng)管理對(duì)象的銷(xiāo)毀工作。在著名的一書(shū) 《深入理解 Java 虛擬機(jī)》中提到一個(gè)觀(guān)點(diǎn)

在 Java 中，我們不再需要手動(dòng)管理對(duì)象的銷(xiāo)毀，它是由?Java 虛擬機(jī)進(jìn)行管理和銷(xiāo)毀的。雖然我們不需要手動(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ì)象

public?class?Apple?{int?i?=?0;Apple?eatApple(){i++;return?this;}public?static?void?main(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 ，如下所示

public?class?Apple?{private?int?num;public?Apple(int?num){this.num?=?num;}public?static?void?main(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)鍵字的效果

public?class?Apple?{private?int?num;private?String?color;public?Apple(int?num){this(num,"紅色");}public?Apple(String?color){this(1,color);}public?Apple(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 就是指向父類(lèi)的一個(gè)引用。super 關(guān)鍵字和 this 一樣，你可以使用?super.對(duì)象?來(lái)引用父類(lèi)的成員，如下

public?class?Fruit?{int?num;String?color;public?void?eat(){System.out.println("eat?Fruit");} }public?class?Apple?extends?Fruit{@Overridepublic?void?eat()?{super.num?=?10;System.out.println("eat?"?+?num?+?"?Apple");}}

你也可以使用?super(參數(shù))?來(lái)調(diào)用父類(lèi)的構(gòu)造函數(shù)，這里不再舉例子了。

下面為你匯總了 this 關(guān)鍵字和 super 關(guān)鍵字的比較。

訪(fǎng)問(wèn)控制權(quán)限

訪(fǎng)問(wèn)控制權(quán)限又稱(chēng)為封裝，它是面向?qū)ο笕筇匦灾械囊环N，我之前在學(xué)習(xí)過(guò)程中經(jīng)常會(huì)忽略封裝，心想這不就是一個(gè)訪(fǎng)問(wèn)修飾符么，怎么就是三大特性的必要條件了？后來(lái)我才知道，如果你信任的下屬對(duì)你隱瞞 bug，你是根本不知道的。

訪(fǎng)問(wèn)控制權(quán)限其實(shí)最核心就是一點(diǎn)：只對(duì)需要的類(lèi)可見(jiàn)。

Java中成員的訪(fǎng)問(wèn)權(quán)限共有四種，分別是?public、protected、default、private，它們的可見(jiàn)性如下

繼承

繼承是所有?OOP(Object Oriented Programming)?語(yǔ)言和 Java 語(yǔ)言都不可或缺的一部分。只要我們創(chuàng)建了一個(gè)類(lèi)，就隱式的繼承自?Object?父類(lèi)，只不過(guò)沒(méi)有指定。如果你顯示指定了父類(lèi)，那么你繼承于父類(lèi)，而你的父類(lèi)繼承于 Object 類(lèi)。

繼承的關(guān)鍵字是?extends?，如上圖所示，如果使用了 extends 顯示指定了繼承，那么我們可以說(shuō) Father 是父類(lèi)，而 Son 是子類(lèi)，用代碼表示如下

class?Father{}class?Son?extends?Father{}

繼承雙方擁有某種共性的特征

class?Father{public?void?feature(){System.out.println("父親的特征");} }class?Son?extends?Father?{ }

如果 Son 沒(méi)有實(shí)現(xiàn)自己的方法的話(huà)，那么默認(rèn)就是用的是父類(lèi)的?feature?方法。如果子類(lèi)實(shí)現(xiàn)了自己的 feature 方法，那么就相當(dāng)于是重寫(xiě)了父類(lèi)的 feature 方法，這也是我們上面提到的重寫(xiě)了。

多態(tài)

多態(tài)指的是同一個(gè)行為具有多個(gè)不同表現(xiàn)形式。是指一個(gè)類(lèi)實(shí)例（對(duì)象）的相同方法在不同情形下具有不同表現(xiàn)形式。封裝和繼承是多態(tài)的基礎(chǔ)，也就是說(shuō)，多態(tài)只是一種表現(xiàn)形式而已。

如何實(shí)現(xiàn)多態(tài)？多態(tài)的實(shí)現(xiàn)具有三種充要條件

• 繼承

• 重寫(xiě)父類(lèi)方法

• 父類(lèi)引用指向子類(lèi)對(duì)象

比如下面這段代碼

public?class?Fruit?{int?num;public?void?eat(){System.out.println("eat?Fruit");} }public?class?Apple?extends?Fruit{@Overridepublic?void?eat()?{super.num?=?10;System.out.println("eat?"?+?num?+?"?Apple");}public?static?void?main(String[]?args)?{Fruit?fruit?=?new?Apple();fruit.eat();} }

你可以發(fā)現(xiàn)?main?方法中有一個(gè)很神奇的地方，Fruit fruit = new Apple()，Fruit 類(lèi)型的對(duì)象竟然指向了 Apple 對(duì)象的引用，這其實(shí)就是多態(tài) -> 父類(lèi)引用指向子類(lèi)對(duì)象，因?yàn)?Apple 繼承于 Fruit，并且重寫(xiě)了 eat 方法，所以能夠表現(xiàn)出來(lái)多種狀態(tài)的形式。

組合

組合其實(shí)不難理解，就是將對(duì)象引用置于新類(lèi)中即可。組合也是一種提高類(lèi)的復(fù)用性的一種方式。如果你想讓類(lèi)具有更多的擴(kuò)展功能，你需要記住一句話(huà)多用組合，少用繼承。

public?class?SoccerPlayer?{private?String?name;private?Soccer?soccer;}public?class?Soccer?{private?String?soccerName;???? }

代碼中 SoccerPlayer 引用了 Soccer 類(lèi)，通過(guò)引用 Soccer 類(lèi)，來(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)系模型稱(chēng)為?代理。代理的大致描述是，A 想要調(diào)用 B 類(lèi)的方法，A 不直接調(diào)用，A 會(huì)在自己的類(lèi)中創(chuàng)建一個(gè) B 對(duì)象的代理，再由代理調(diào)用 B 的方法。例如如下代碼

public?class?Destination?{public?void?todo(){System.out.println("control...");} }public?class?Device?{private?String?name;private?Destination?destination;private?DeviceController?deviceController;public?void?control(Destination?destination){destination.todo();}}public?class?DeviceController?{private?Device?name;private?Destination?destination;public?void?control(Destination?destination){destination.todo();} }

向上轉(zhuǎn)型

向上轉(zhuǎn)型代表了父類(lèi)與子類(lèi)之間的關(guān)系，其實(shí)父類(lèi)和子類(lèi)之間不僅僅有向上轉(zhuǎn)型，還有向下轉(zhuǎn)型，它們的轉(zhuǎn)型后的范圍不一樣

• 向上轉(zhuǎn)型：通過(guò)子類(lèi)對(duì)象(小范圍)轉(zhuǎn)化為父類(lèi)對(duì)象(大范圍)，這種轉(zhuǎn)換是自動(dòng)完成的，不用強(qiáng)制。

• 向下轉(zhuǎn)型?: 通過(guò)父類(lèi)對(duì)象(大范圍)實(shí)例化子類(lèi)對(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)成員變量，也成為類(lèi)變量。類(lèi)變量的生命周期和類(lèi)相同，在整個(gè)應(yīng)用程序執(zhí)行期間都有效。

static?String?name?=?"cxuan";

• 使用 static 修飾的方法稱(chēng)為靜態(tài)方法，靜態(tài)方法能夠直接使用類(lèi)名.方法名?進(jìn)行調(diào)用。由于靜態(tài)方法不依賴(lài)于任何對(duì)象就可以直接訪(fǎng)問(wèn)，因此對(duì)于靜態(tài)方法來(lái)說(shuō)，是沒(méi)有 this 關(guān)鍵字的，實(shí)例變量都會(huì)有 this 關(guān)鍵字。在靜態(tài)方法中不能訪(fǎng)問(wèn)類(lèi)的非靜態(tài)成員變量和非靜態(tài)方法，

static?void?printMessage(){System.out.println("cxuan?is?writing?the?article"); }

static 除了修飾屬性和方法外，還有靜態(tài)代碼塊?的功能，可用于類(lèi)的初始化操作。進(jìn)而提升程序的性能。

public?class?StaicBlock?{static{System.out.println("I'm?A?static?code?block");} }

由于靜態(tài)代碼塊隨著類(lèi)的加載而執(zhí)行，因此，很多時(shí)候會(huì)將只需要進(jìn)行一次的初始化操作放在 static 代碼塊中進(jìn)行。

final

final 的意思是最后的、最終的，它可以修飾類(lèi)、屬性和方法。

• final 修飾類(lèi)時(shí)，表明這個(gè)類(lèi)不能被繼承。final 類(lèi)中的成員變量可以根據(jù)需要設(shè)為 final，但是要注意 final 類(lèi)中的所有成員方法都會(huì)被隱式地指定為 final 方法。

• final 修飾方法時(shí)，表明這個(gè)方法不能被任何子類(lèi)重寫(xiě)，因此，如果只有在想明確禁止該方法在子類(lèi)中被覆蓋的情況下才將方法設(shè)置為 final。

• final 修飾變量分為兩種情況，一種是修飾基本數(shù)據(jù)類(lèi)型，表示數(shù)據(jù)類(lèi)型的值不能被修改；一種是修飾引用類(lèi)型，表示對(duì)其初始化之后便不能再讓其指向另一個(gè)對(duì)象。

接口和抽象類(lèi)

接口

接口相當(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è)接口

public?interface?CxuanGoodJob?{}

比如我們定義了一個(gè) CxuanGoodJob 的接口，然后你就可以在其內(nèi)部定義 cxuan 做的好的那些事情，比如 cxuan 寫(xiě)的文章不錯(cuò)。

public?interface?CxuanGoodJob?{void?writeWell(); }

這里隱含了一些接口的特征：

• interface?接口是一個(gè)完全抽象的類(lèi)，他不會(huì)提供任何方法的實(shí)現(xiàn)，只是會(huì)進(jìn)行方法的定義。

• 接口中只能使用兩種訪(fǎng)問(wèn)修飾符，一種是?public，它對(duì)整個(gè)項(xiàng)目可見(jiàn)；一種是?default?缺省值，它只具有包訪(fǎng)問(wèn)權(quán)限。

• 接口只提供方法的定義，接口沒(méi)有實(shí)現(xiàn)，但是接口可以被其他類(lèi)實(shí)現(xiàn)。也就是說(shuō)，實(shí)現(xiàn)接口的類(lèi)需要提供方法的實(shí)現(xiàn)，實(shí)現(xiàn)接口使用?implements?關(guān)鍵字來(lái)表示，一個(gè)接口可以有多個(gè)實(shí)現(xiàn)。

class?CXuanWriteWell?implements?CxuanGoodJob{@Overridepublic?void?writeWell()?{System.out.println("Cxuan?write?Java?is?vary?well");} }

• 接口不能被實(shí)例化，所以接口中不能有任何構(gòu)造方法，你定義構(gòu)造方法編譯會(huì)出錯(cuò)。

• 接口的實(shí)現(xiàn)比如實(shí)現(xiàn)接口的全部方法，否則必須定義為抽象類(lèi)，這就是我們下面要說(shuō)的內(nèi)容

抽象類(lèi)

抽象類(lèi)是一種抽象能力弱于接口的類(lèi)，在 Java 中，抽象類(lèi)使用?abstract?關(guān)鍵字來(lái)表示。如果把接口形容為狗這個(gè)物種，那么抽象類(lèi)可以說(shuō)是毛發(fā)是白色、小體的品種，而實(shí)現(xiàn)類(lèi)可以是具體的類(lèi)，比如說(shuō)是博美、泰迪等。你可以像下面這樣定義抽象類(lèi)

public?interface?Dog?{void?FurColor();}abstract?class?WhiteDog?implements?Dog{public?void?FurColor(){System.out.println("Fur?is?white");}abstract?void?SmallBody(); }

在抽象類(lèi)中，具有如下特征

• 如果一個(gè)類(lèi)中有抽象方法，那么這個(gè)類(lèi)一定是抽象類(lèi)，也就是說(shuō)，使用關(guān)鍵字?abstract?修飾的方法一定是抽象方法，具有抽象方法的類(lèi)一定是抽象類(lèi)。實(shí)現(xiàn)類(lèi)方法中只有方法具體的實(shí)現(xiàn)。

• 抽象類(lèi)中不一定只有抽象方法，抽象類(lèi)中也可以有具體的方法，你可以自己去選擇是否實(shí)現(xiàn)這些方法。

• 抽象類(lèi)中的約束不像接口那么嚴(yán)格，你可以在抽象類(lèi)中定義?構(gòu)造方法、抽象方法、普通屬性、方法、靜態(tài)屬性和靜態(tài)方法

• 抽象類(lèi)和接口一樣不能被實(shí)例化，實(shí)例化只能實(shí)例化具體的類(lèi)

異常

異常是程序經(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?類(lèi)，Exception 類(lèi)及其子類(lèi)都是 Throwable 的組成條件，是程序出現(xiàn)的合理情況。

在認(rèn)識(shí) Exception 之前，有必要先了解一下什么是?Throwable。

什么是 Throwable

Throwable 類(lèi)是 Java 語(yǔ)言中所有錯(cuò)誤(errors)和異常(exceptions)的父類(lèi)。只有繼承于 Throwable 的類(lèi)或者其子類(lèi)才能夠被拋出，還有一種方式是帶有 Java 中的?@throw?注解的類(lèi)也可以?huà)伋觥?/p>

在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?和其子類(lèi)，以及error和其子類(lèi)，其它的所有異常都是?checkedException。

那么，按照這種邏輯關(guān)系，我們可以對(duì) Throwable 及其子類(lèi)進(jìn)行歸類(lèi)分析

可以看到，Throwable 位于異常和錯(cuò)誤的最頂層，我們查看 Throwable 類(lèi)中發(fā)現(xiàn)它的方法和屬性有很多，我們只討論其中幾個(gè)比較常用的

//?返回拋出異常的詳細(xì)信息 public?string?getMessage(); public?string?getLocalizedMessage();//返回異常發(fā)生時(shí)的簡(jiǎn)要描述 public?public?String?toString()；//?打印異常信息到標(biāo)準(zhǔn)輸出流上 public?void?printStackTrace(); public?void?printStackTrace(PrintStream?s); public?void?printStackTrace(PrintWriter?s)//?記錄棧幀的的當(dāng)前狀態(tài) public?synchronized?Throwable?fillInStackTrace();

此外，因?yàn)?Throwable 的父類(lèi)也是?Object，所以常用的方法還有繼承其父類(lèi)的getClass()?和?getName()?方法。

常見(jiàn)的 Exception

下面我們回到 Exception 的探討上來(lái)，現(xiàn)在你知道了 Exception 的父類(lèi)是 Throwable，并且 Exception 有兩種異常，一種是?RuntimeException?；一種是?CheckedException，這兩種異常都應(yīng)該去捕獲。

下面列出了一些 Java 中常見(jiàn)的異常及其分類(lèi)，這塊面試官也可能讓你舉出幾個(gè)常見(jiàn)的異常情況并將其分類(lèi)

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)的，例如

static?void?cacheException()?throws?Exception{throw?new?Exception();}

throw 語(yǔ)句用在方法體內(nèi)，表示拋出異常，由方法體內(nèi)的語(yǔ)句處理。throws 語(yǔ)句用在方法聲明后面，表示再拋出異常，由該方法的調(diào)用者來(lái)處理。

throws 主要是聲明這個(gè)方法會(huì)拋出這種類(lèi)型的異常，使它的調(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)行的捕獲，如下

static?void?cacheException()?throws?Exception{try?{System.out.println("1");}catch?(Exception?e){e.printStackTrace();}}

try...finally 表示對(duì)一段代碼不管執(zhí)行情況如何，都會(huì)走 finally 中的代碼

static?void?cacheException()?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。

其中包括兩部分，由所有線(xiàn)程共享的數(shù)據(jù)區(qū)和線(xiàn)程隔離的數(shù)據(jù)區(qū)組成，在上面的 Java 內(nèi)存模型中，只有程序計(jì)數(shù)器是不會(huì)發(fā)生?OutOfMemoryError?情況的區(qū)域，程序計(jì)數(shù)器控制著計(jì)算機(jī)指令的分支、循環(huán)、跳轉(zhuǎn)、異常處理和線(xiàn)程恢復(fù)，并且程序計(jì)數(shù)器是每個(gè)線(xiàn)程私有的。

“

什么是線(xiàn)程私有：表示的就是各條線(xiàn)程之間互不影響，獨(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ī)棧：如果線(xiàn)程請(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ù)，就像我們的磁盤(pán)空間一樣，如果堆中沒(méi)有內(nèi)存完成實(shí)例分配，并且堆無(wú)法擴(kuò)展時(shí)，將會(huì)拋出 OutOfMemoryError。

• 方法區(qū)：方法區(qū)無(wú)法滿(mǎn)足內(nèi)存分配需求時(shí)，將拋出 OutOfMemoryError 異常。

在 Java 中，你可以把異常理解為是一種能夠提高你程序健壯性的機(jī)制，它能夠讓你在編寫(xiě)代碼中注意這些問(wèn)題，也可以說(shuō)，如果你寫(xiě)代碼不會(huì)注意這些異常情況，你是無(wú)法成為一位硬核程序員的。

內(nèi)部類(lèi)

距今為止，我們了解的都是普通類(lèi)的定義，那就是直接在 IDEA 中直接新建一個(gè) class 。

新建完成后，你就會(huì)擁有一個(gè) class 文件的定義，這種操作太簡(jiǎn)單了，時(shí)間長(zhǎng)了就會(huì)枯燥，我們年輕人多需要更新潮和騷氣的寫(xiě)法，好吧，既然你提到了那就使用?內(nèi)部類(lèi)吧，這是一種有用而且騷氣的定義類(lèi)的方式，內(nèi)部類(lèi)的定義非常簡(jiǎn)單：可以將一個(gè)類(lèi)的定義放在另一個(gè)類(lèi)的內(nèi)部，這就是內(nèi)部類(lèi)。

內(nèi)部類(lèi)是一種非常有用的特性，定義在類(lèi)內(nèi)部的類(lèi)，持有外部類(lèi)的引用，但卻對(duì)其他外部類(lèi)不可見(jiàn)，看起來(lái)就像是一種隱藏代碼的機(jī)制，就和?弗蘭奇將軍?似的，弗蘭奇可以和弗蘭奇將軍進(jìn)行通訊，但是外面的敵人卻無(wú)法直接攻擊到弗蘭奇本體。

下面我們就來(lái)聊一聊創(chuàng)建內(nèi)部類(lèi)的方式。

創(chuàng)建內(nèi)部類(lèi)

定義內(nèi)部類(lèi)非常簡(jiǎn)單，就是直接將一個(gè)類(lèi)定義在外圍類(lèi)的里面，如下代碼所示

public?class?OuterClass?{private?String?name?;private?int?age;class?InnerClass{public?InnerClass(){name?=?"cxuan";age?=?25;}} }

在這段代碼中，InnerClass 就是 OuterClass 的一個(gè)內(nèi)部類(lèi)。也就是說(shuō)，每個(gè)內(nèi)部類(lèi)都能獨(dú)立地繼承一個(gè)（接口的）實(shí)現(xiàn)，所以無(wú)論外圍類(lèi)是否已經(jīng)繼承了某個(gè)（接口的）實(shí)現(xiàn)，對(duì)于內(nèi)部類(lèi)都沒(méi)有影響。這也是隱藏了內(nèi)部實(shí)現(xiàn)細(xì)節(jié)。內(nèi)部類(lèi)擁有外部類(lèi)的訪(fǎng)問(wèn)權(quán)。

內(nèi)部類(lèi)不僅僅能夠定義在類(lèi)的內(nèi)部，還可以定義在方法和作用域內(nèi)部，這種被稱(chēng)為局部?jī)?nèi)部類(lèi)，除此之外，還有匿名內(nèi)部類(lèi)、內(nèi)部類(lèi)可以實(shí)現(xiàn) Java 中的?多重繼承。下面是定義內(nèi)部類(lèi)的方式

• 一個(gè)在方法中定義的類(lèi)(局部?jī)?nèi)部類(lèi))
• 一個(gè)定義在作用域內(nèi)的類(lèi)，這個(gè)作用域在方法的內(nèi)部(成員內(nèi)部類(lèi))
• 一個(gè)實(shí)現(xiàn)了接口的匿名類(lèi)(匿名內(nèi)部類(lèi))
• 一個(gè)匿名類(lèi)，它擴(kuò)展了非默認(rèn)構(gòu)造器的類(lèi)
• 一個(gè)匿名類(lèi)，執(zhí)行字段初始化操作
• 一個(gè)匿名類(lèi)，它通過(guò)實(shí)例初始化實(shí)現(xiàn)構(gòu)造

由于每個(gè)類(lèi)都會(huì)產(chǎn)生一個(gè)?.class?文件，其中包含了如何創(chuàng)建該類(lèi)型的對(duì)象的全部信息，那么，如何表示內(nèi)部類(lè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)行元素的添加和刪除的話(huà)，就盡量使用迭代器進(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 等集合元素的父類(lèi)

Set 接口位于與 List 接口同級(jí)的層次上，它同時(shí)也繼承了 Collection 接口。Set 接口提供了額外的規(guī)定。它對(duì)add、equals、hashCode ?方法提供了額外的標(biāo)準(zhǔn)。

Queue 是和 List、Set 接口并列的 Collection 的三大接口之一。Queue 的設(shè)計(jì)用來(lái)在處理之前保持元素的訪(fǎng)問(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 類(lèi)，Dictionary 是一個(gè)抽象類(lèi)而不是接口。

ArrayList

ArrayList 是實(shí)現(xiàn)了 List 接口的可擴(kuò)容數(shù)組(動(dòng)態(tài)數(shù)組)，它的內(nèi)部是基于數(shù)組實(shí)現(xiàn)的。它的具體定義如下：

public?class?ArrayList<E>?extends?AbstractList<E>?implements?List<E>,?RandomAccess,?Cloneable,?java.io.Serializable?{...}

• ArrayList 可以實(shí)現(xiàn)所有可選擇的列表操作，允許所有的元素，包括空值。ArrayList 還提供了內(nèi)部存儲(chǔ) list 的方法，它能夠完全替代 Vector，只有一點(diǎn)例外，ArrayList 不是線(xiàn)程安全的容器。

• ArrayList 有一個(gè)容量的概念，這個(gè)數(shù)組的容量就是 List 用來(lái)存儲(chǔ)元素的容量。

• ArrayList 不是線(xiàn)程安全的容器，如果多個(gè)線(xiàn)程中至少有兩個(gè)線(xiàn)程修改了 ArrayList 的結(jié)構(gòu)的話(huà)就會(huì)導(dǎo)致線(xiàn)程安全問(wèn)題，作為替代條件可以使用線(xià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è)線(xiàn)程安全的容器，它對(duì)內(nèi)部的每個(gè)方法都簡(jiǎn)單粗暴的上鎖，避免多線(xiàn)程引起的安全性問(wèn)題，但是通常這種同步方式需要的開(kāi)銷(xiāo)比較大，因此，訪(fǎng)問(wèn)元素的效率要遠(yuǎn)遠(yuǎn)低于 ArrayList。

還有一點(diǎn)在于擴(kuò)容上，ArrayList 擴(kuò)容后的數(shù)組長(zhǎng)度會(huì)增加 50%，而 Vector 的擴(kuò)容長(zhǎng)度后數(shù)組會(huì)增加一倍。

LinkedList 類(lèi)

LinkedList 是一個(gè)雙向鏈表，允許存儲(chǔ)任何元素(包括 null )。它的主要特性如下：

• LinkedList 所有的操作都可以表現(xiàn)為雙向性的，索引到鏈表的操作將遍歷從頭到尾，視哪個(gè)距離近為遍歷順序。

• 注意這個(gè)實(shí)現(xiàn)也不是線(xiàn)程安全的，如果多個(gè)線(xiàn)程并發(fā)訪(fǎng)問(wèn)鏈表，并且至少其中的一個(gè)線(xiàn)程修改了鏈表的結(jié)構(gòu)，那么這個(gè)鏈表必須進(jìn)行外部加鎖。或者使用

List?list?=?Collections.synchronizedList(new?LinkedList(...))

Stack

堆棧是我們常說(shuō)的后入先出(吃了吐)的容器 。它繼承了 Vector 類(lèi)，提供了通常用的 push 和 pop 操作，以及在棧頂?shù)?peek 方法，測(cè)試 stack 是否為空的 empty 方法，和一個(gè)尋找與棧頂距離的 search 方法。

第一次創(chuàng)建棧，不包含任何元素。一個(gè)更完善，可靠性更強(qiáng)的 LIFO 棧操作由 Deque 接口和他的實(shí)現(xiàn)提供，應(yīng)該優(yōu)先使用這個(gè)類(lèi)

Deque<Integer>?stack?=?new?ArrayDeque<Integer>()

HashSet

HashSet 是 Set 接口的實(shí)現(xiàn)類(lèi)，由哈希表支持(實(shí)際上 HashSet 是 HashMap 的一個(gè)實(shí)例)。它不能保證集合的迭代順序。這個(gè)類(lèi)允許 null 元素。

• 注意這個(gè)實(shí)現(xiàn)不是線(xiàn)程安全的。如果多線(xiàn)程并發(fā)訪(fǎng)問(wèn) HashSet，并且至少一個(gè)線(xiàn)程修改了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)不是線(xiàn)程安全的。如果多線(xiàn)程并發(fā)訪(fǎng)問(wèn) TreeSet，并且至少一個(gè)線(xiàn)程修改了 set，必須進(jìn)行外部加鎖。或者使用

SortedSet?s?=?Collections.synchronizedSortedSet(new?TreeSet(...))

• 這個(gè)實(shí)現(xiàn)持有 fail-fast 機(jī)制。

LinkedHashSet 類(lèi)

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)銷(xiāo)要比 HashSet 小，因?yàn)?LinkedHashSet 的迭代次數(shù)不受容量影響。

• 注意 LinkedHashSet 也不是線(xiàn)程安全的，如果多線(xiàn)程同時(shí)訪(fǎng)問(wèn) LinkedHashSet，必須加鎖，或者通過(guò)使用

Collections.synchronizedSet

• 該類(lèi)也支持fail-fast機(jī)制

PriorityQueue

PriorityQueue 是 AbstractQueue 的實(shí)現(xiàn)類(lèi)，優(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 訪(fǎng)問(wèn)隊(duì)列頭部元素。

• 優(yōu)先級(jí)隊(duì)列是無(wú)限制的，但具有內(nèi)部 capacity，用于控制用于在隊(duì)列中存儲(chǔ)元素的數(shù)組大小。

• 該類(lèi)以及迭代器實(shí)現(xiàn)了 Collection、Iterator 接口的所有可選方法。這個(gè)迭代器提供了?iterator()?方法不能保證以任何特定順序遍歷優(yōu)先級(jí)隊(duì)列的元素。如果你需要有序遍歷，考慮使用?Arrays.sort(pq.toArray())。

• 注意這個(gè)實(shí)現(xiàn)不是線(xiàn)程安全的，多線(xiàn)程不應(yīng)該并發(fā)訪(fǎng)問(wèn) PriorityQueue 實(shí)例如果有某個(gè)線(xiàn)程修改了隊(duì)列的話(huà)，使用線(xiàn)程安全的類(lèi)?PriorityBlockingQueue。

HashMap

HashMap 是一個(gè)利用哈希表原理來(lái)存儲(chǔ)元素的集合，并且允許空的 key-value 鍵值對(duì)。HashMap 是非線(xiàn)程安全的，也就是說(shuō)在多線(xiàn)程的環(huán)境下，可能會(huì)存在問(wèn)題，而 Hashtable 是線(xiàn)程安全的容器。HashMap 也支持 fail-fast 機(jī)制。HashMap 的實(shí)例有兩個(gè)參數(shù)影響其性能：初始容量 和加載因子。可以使用?Collections.synchronizedMap(new HashMap(...))?來(lái)構(gòu)造一個(gè)線(xiàn)程安全的 HashMap。

TreeMap 類(lèi)

一個(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)銷(xiāo)。

• 注意這個(gè)實(shí)現(xiàn)不是線(xiàn)程安全的。如果多線(xiàn)程并發(fā)訪(fǎng)問(wèn) TreeMap，并且至少一個(gè)線(xiàn)程修改了 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 類(lèi)

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，其遍歷順序是其最后一次訪(fǎng)問(wèn)的順序。

• 可以重寫(xiě) removeEldestEntry(Map.Entry) 方法，以便在將新映射添加到 map 時(shí)強(qiáng)制刪除過(guò)期映射的策略。

• 這個(gè)類(lèi)提供了所有可選擇的 map 操作，并且允許 null 元素。由于維護(hù)鏈表的額外開(kāi)銷(xiāo)，性能可能會(huì)低于HashMap，有一條除外：遍歷 LinkedHashMap 中的 collection-views 需要與 map.size 成正比，無(wú)論其容量如何。HashMap 的迭代看起來(lái)開(kāi)銷(xiāo)更大，因?yàn)檫€要求時(shí)間與其容量成正比。

• LinkedHashMap 有兩個(gè)因素影響了它的構(gòu)成：初始容量和加載因子。

• 注意這個(gè)實(shí)現(xiàn)不是線(xiàn)程安全的。如果多線(xiàn)程并發(fā)訪(fǎng)問(wèn)LinkedHashMap，并且至少一個(gè)線(xiàn)程修改了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 類(lèi)

Hashtable 類(lèi)實(shí)現(xiàn)了一個(gè)哈希表，能夠?qū)㈡I映射到值。任何非空對(duì)象都可以用作鍵或值。

• 此實(shí)現(xiàn)類(lèi)支持 fail-fast 機(jī)制

• 與新的集合實(shí)現(xiàn)不同，Hashtable 是線(xiàn)程安全的。如果不需要線(xiàn)程安全的容器，推薦使用 HashMap，如果需要多線(xiàn)程高并發(fā)，推薦使用?ConcurrentHashMap。

IdentityHashMap 類(lèi)

IdentityHashMap 是比較小眾的 Map 實(shí)現(xiàn)了。

• 這個(gè)類(lèi)不是一個(gè)通用的 Map 實(shí)現(xiàn)！雖然這個(gè)類(lèi)實(shí)現(xiàn)了 Map 接口，但它故意違反了 Map 的約定，該約定要求在比較對(duì)象時(shí)使用 equals 方法，此類(lèi)僅適用于需要引用相等語(yǔ)義的極少數(shù)情況。

• 同 HashMap，IdentityHashMap 也是無(wú)序的，并且該類(lèi)不是線(xiàn)程安全的，如果要使之線(xiàn)程安全，可以調(diào)用Collections.synchronizedMap(new IdentityHashMap(...))方法來(lái)實(shí)現(xiàn)。

• 支持fail-fast機(jī)制

WeakHashMap 類(lèi)

WeakHashMap 類(lèi)基于哈希表的 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 類(lèi)

Collections 不屬于 Java 框架繼承樹(shù)上的內(nèi)容，它屬于單獨(dú)的分支，Collections 是一個(gè)包裝類(lèi)，它的作用就是為集合框架提供某些功能實(shí)現(xiàn)，此類(lèi)只包括靜態(tài)方法操作或者返回 collections。

同步包裝

同步包裝器將自動(dòng)同步（線(xiàn)程安全性）添加到任意集合。六個(gè)核心集合接口（Collection，Set，List，Map，SortedSet 和 SortedMap）中的每一個(gè)都有一個(gè)靜態(tài)工廠(chǎng)方法。

public?static??Collection?synchronizedCollection(Collection?c); public?static??Set?synchronizedSet(Set?s); public?static??List?synchronizedList(List?list); public?static?<K,V>?Map<K,V>?synchronizedMap(Map<K,V>?m); public?static??SortedSet?synchronizedSortedSet(SortedSet?s); public?static?<K,V>?SortedMap<K,V>?synchronizedSortedMap(SortedMap<K,V>?m);

不可修改的包裝

不可修改的包裝器通過(guò)攔截修改集合的操作并拋出?UnsupportedOperationException，主要用在下面兩個(gè)情景：

• 構(gòu)建集合后使其不可變。在這種情況下，最好不要去獲取返回 collection 的引用，這樣有利于保證不變性

• 允許某些客戶(hù)端以只讀方式訪(fǎng)問(wèn)你的數(shù)據(jù)結(jié)構(gòu)。你保留對(duì)返回的 collection 的引用，但分發(fā)對(duì)包裝器的引用。通過(guò)這種方式，客戶(hù)可以查看但不能修改，同時(shí)保持完全訪(fǎng)問(wèn)權(quán)限。

這些方法是：

public?static??Collection?unmodifiableCollection(Collection<??extends?T>?c); public?static??Set?unmodifiableSet(Set<??extends?T>?s); public?static??List?unmodifiableList(List<??extends?T>?list); public?static?<K,V>?Map<K,?V>?unmodifiableMap(Map<??extends?K,???extends?V>?m); public?static??SortedSet?unmodifiableSortedSet(SortedSet<??extends?T>?s); public?static?<K,V>?SortedMap<K,?V>?unmodifiableSortedMap(SortedMap<K,???extends?V>?m);

線(xiàn)程安全的Collections

Java1.5 并發(fā)包?(java.util.concurrent)?提供了線(xiàn)程安全的 collections 允許遍歷的時(shí)候進(jìn)行修改，通過(guò)設(shè)計(jì)iterator 為 fail-fast 并拋出 ConcurrentModificationException。一些實(shí)現(xiàn)類(lèi)是CopyOnWriteArrayList，ConcurrentHashMap，CopyOnWriteArraySet

Collections 算法

此類(lèi)包含用于集合框架算法的方法，例如二進(jìn)制搜索，排序，重排，反向等。

集合實(shí)現(xiàn)類(lèi)特征圖

下圖匯總了部分集合框架的主要實(shí)現(xiàn)類(lèi)的特征圖，讓你能有清晰明了看出每個(gè)實(shí)現(xiàn)類(lèi)之間的差異性

還有一種類(lèi)型是關(guān)于強(qiáng)引用、弱引用、虛引用的文章，請(qǐng)參考

https://mp.weixin.qq.com/s/ZflBpn2TBzTNv_-G-zZxNg

泛形

在 Jdk1.5 中，提出了一種新的概念，那就是泛型，那么什么是泛型呢？

泛型其實(shí)就是一種參數(shù)化的集合，它限制了你添加進(jìn)集合的類(lèi)型。泛型的本質(zhì)就是一種參數(shù)化類(lèi)型。多態(tài)也可以看作是泛型的機(jī)制。一個(gè)類(lèi)繼承了父類(lèi)，那么就能通過(guò)它的父類(lèi)找到對(duì)應(yīng)的子類(lèi)，但是不能通過(guò)其他類(lèi)來(lái)找到具體要找的這個(gè)類(lèi)。泛型的設(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 ?類(lèi)型不能直接強(qiáng)制轉(zhuǎn)換為 String 類(lèi)型

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)類(lèi)似這樣的問(wèn)題。

泛型的使用

泛型的使用有多種方式，下面我們就來(lái)一起探討一下。

用泛型表示類(lèi)

泛型可以加到類(lèi)上面，來(lái)表示這個(gè)類(lèi)的類(lèi)型

//此處?T?可以隨便寫(xiě)為任意標(biāo)識(shí)，常見(jiàn)的如T、E、K、V等形式的參數(shù)常用于表示泛型 public?class?GenericDemo<T>{?//value?這個(gè)成員變量的類(lèi)型為T(mén),T的類(lèi)型由外部指定??private?T?value;public?GenericDemo(T?value)?{this.value?=?value;}public?T?getValue(){?//泛型方法getKey的返回值類(lèi)型為T(mén)，T的類(lèi)型由外部指定return?value;}public?void?setValue(T?value){this.value?=?value} }

用泛型表示接口

泛型接口與泛型類(lèi)的定義及使用基本相同。

//定義一個(gè)泛型接口 public?interface?Generator<T>?{public?T?next(); }

一般泛型接口常用于?生成器(generator)?中，生成器相當(dāng)于對(duì)象工廠(chǎng)，是一種專(zhuān)門(mén)用來(lái)創(chuàng)建對(duì)象的類(lèi)。

泛型方法

可以使用泛型來(lái)表示方法

public?class?GenericMethods?{public?<T>?void?f(T?x){System.out.println(x.getClass().getName());} }

泛型通配符

List 是泛型類(lèi)，為了 表示各種泛型 List 的父類(lèi)，可以使用類(lèi)型通配符，類(lèi)型通配符使用問(wèn)號(hào)(?)表示，它的元素類(lèi)型可以匹配任何類(lèi)型。例如

public?static?void?main(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);??? }public?static?void?generic(List<?>?data)?{System.out.println("Test?cxuan?:"?+?data.get(0)); }

上界通配符?: ?<? extends ClassType> 該通配符為 ClassType 的所有子類(lèi)型。它表示的是任何類(lèi)型都是 ClassType 類(lèi)型的子類(lèi)。

下界通配符：<? super ClassType> 該通配符為 ClassType 的所有超類(lèi)型。它表示的是任何類(lèi)型的父類(lèi)都是 ClassType。

反射

反射是 Java 中一個(gè)非常重要同時(shí)也是一個(gè)高級(jí)特性，基本上 Spring 等一系列框架都是基于反射的思想寫(xiě)成的。我們首先來(lái)認(rèn)識(shí)一下什么反射。

Java 反射機(jī)制是在程序的運(yùn)行過(guò)程中，對(duì)于任何一個(gè)類(lèi)，都能夠知道它的所有屬性和方法；對(duì)于任意一個(gè)對(duì)象，都能夠知道調(diào)用它的任意屬性和方法，這種動(dòng)態(tài)獲取信息以及動(dòng)態(tài)調(diào)用對(duì)象方法的功能稱(chēng)為java語(yǔ)言的反射機(jī)制。（來(lái)源于百度百科）

Java 反射機(jī)制主要提供了以下這幾個(gè)功能

• 在運(yùn)行時(shí)判斷任意一個(gè)對(duì)象所屬的類(lèi)

• 在運(yùn)行時(shí)構(gòu)造任意一個(gè)類(lèi)的對(duì)象

• 在運(yùn)行時(shí)判斷任意一個(gè)類(lèi)所有的成員變量和方法

• 在運(yùn)行時(shí)調(diào)用任意一個(gè)對(duì)象的方法

這么一看，反射就像是一個(gè)掌控全局的角色，不管你程序怎么運(yùn)行，我都能夠知道你這個(gè)類(lèi)有哪些屬性和方法，你這個(gè)對(duì)象是由誰(shuí)調(diào)用的，嗯，很屌。

在 Java 中，使用?Java.lang.reflect包實(shí)現(xiàn)了反射機(jī)制。Java.lang.reflect 所設(shè)計(jì)的類(lèi)如下

下面是一個(gè)簡(jiǎn)單的反射類(lèi)

public?class?Person?{public?String?name;//?姓名public?int?age;//?年齡public?Person()?{super();}public?Person(String?name,?int?age)?{super();this.name?=?name;this.age?=?age;}public?String?showInfo()?{return?"name="?+?name?+?",?age="?+?age;} }public?class?Student?extends?Person?implements?Study?{public?String?className;//?班級(jí)private?String?address;//?住址public?Student()?{super();}public?Student(String?name,?int?age,?String?className,?String?address)?{super(name,?age);this.className?=?className;this.address?=?address;}public?Student(String?className)?{this.className?=?className;}public?String?toString()?{return?"姓名："?+?name?+?",年齡："?+?age?+?",班級(jí)："?+?className?+?",住址："+?address;}public?String?getAddress()?{return?address;}public?void?setAddress(String?address)?{this.address?=?address;} }public?class?TestRelect?{public?static?void?main(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è)歸類(lèi)。

與 Java 反射有關(guān)的類(lèi)主要有

Class 類(lèi)

在 Java 中，你每定義一個(gè) java class 實(shí)體都會(huì)產(chǎn)生一個(gè) Class 對(duì)象。也就是說(shuō)，當(dāng)我們編寫(xiě)一個(gè)類(lèi)，編譯完成后，在生成的?.class?文件中，就會(huì)產(chǎn)生一個(gè) Class 對(duì)象，這個(gè) Class 對(duì)象用于表示這個(gè)類(lèi)的類(lèi)型信息。Class 中沒(méi)有公共的構(gòu)造器，也就是說(shuō) Class 對(duì)象不能被實(shí)例化。下面來(lái)簡(jiǎn)單看一下 Class 類(lèi)都包括了哪些方法

toString()

public?String?toString()?{return?(isInterface()???"interface?"?:?(isPrimitive()???""?:?"class?"))+?getName(); }

toString() 方法能夠?qū)?duì)象轉(zhuǎn)換為字符串，toString() 首先會(huì)判斷 Class 類(lèi)型是否是接口類(lèi)型，也就是說(shuō)，普通類(lèi)和接口都能夠用 Class 對(duì)象來(lái)表示，然后再判斷是否是基本數(shù)據(jù)類(lèi)型，這里判斷的都是基本數(shù)據(jù)類(lèi)型和包裝類(lèi)，還有?void類(lèi)型。

所有的類(lèi)型如下

• java.lang.Boolean : 代表 boolean 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Character: 代表 char 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Byte: 代表 byte 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Short: 代表 short 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Integer: 代表 int 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Long: 代表 long 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Float: 代表 float 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Double: 代表 double 數(shù)據(jù)類(lèi)型的包裝類(lèi)

• java.lang.Void: 代表 void 數(shù)據(jù)類(lèi)型的包裝類(lèi)

然后是?getName()?方法，這個(gè)方法返回類(lèi)的全限定名稱(chēng)。

• 如果是引用類(lèi)型，比如 String.class.getName() ?->?java.lang.String

• 如果是基本數(shù)據(jù)類(lèi)型，byte.class.getName() ->?byte

• 如果是數(shù)組類(lèi)型，new Object[3]).getClass().getName() ->?[Ljava.lang.Object

toGenericString()

這個(gè)方法會(huì)返回類(lèi)的全限定名稱(chēng)，而且包括類(lèi)的修飾符和類(lèi)型參數(shù)信息。

forName()

根據(jù)類(lèi)名獲得一個(gè) Class 對(duì)象的引用，這個(gè)方法會(huì)使類(lèi)對(duì)象進(jìn)行初始化。

例如?Class t = Class.forName("java.lang.Thread")?就能夠初始化一個(gè) Thread 線(xiàn)程對(duì)象

在 Java 中，一共有三種獲取類(lèi)實(shí)例的方式

• Class.forName(java.lang.Thread)

• Thread.class

• thread.getClass()

newInstance()

創(chuàng)建一個(gè)類(lèi)的實(shí)例，代表著這個(gè)類(lèi)的對(duì)象。上面 forName() 方法對(duì)類(lèi)進(jìn)行初始化，newInstance 方法對(duì)類(lèi)進(jìn)行實(shí)例化。

getClassLoader()

獲取類(lèi)加載器對(duì)象。

getTypeParameters()

按照聲明的順序獲取對(duì)象的參數(shù)類(lèi)型信息。

getPackage()

返回類(lèi)的包

getInterfaces()

獲得當(dāng)前類(lèi)實(shí)現(xiàn)的類(lèi)或是接口，可能是有多個(gè)，所以返回的是 Class 數(shù)組。

Cast

把對(duì)象轉(zhuǎn)換成代表類(lèi)或是接口的對(duì)象

asSubclass(Class clazz)

把傳遞的類(lèi)的對(duì)象轉(zhuǎn)換成代表其子類(lèi)的對(duì)象

getClasses()

返回一個(gè)數(shù)組，數(shù)組中包含該類(lèi)中所有公共類(lèi)和接口類(lèi)的對(duì)象

getDeclaredClasses()

返回一個(gè)數(shù)組，數(shù)組中包含該類(lèi)中所有類(lèi)和接口類(lèi)的對(duì)象

getSimpleName()

獲得類(lèi)的名字

getFields()

獲得所有公有的屬性對(duì)象

getField(String name)

獲得某個(gè)公有的屬性對(duì)象

getDeclaredField(String name)

獲得某個(gè)屬性對(duì)象

getDeclaredFields()

獲得所有屬性對(duì)象

getAnnotation(Class annotationClass)

返回該類(lèi)中與參數(shù)類(lèi)型匹配的公有注解對(duì)象

getAnnotations()

返回該類(lèi)所有的公有注解對(duì)象

getDeclaredAnnotation(Class annotationClass)

返回該類(lèi)中與參數(shù)類(lèi)型匹配的所有注解對(duì)象

getDeclaredAnnotations()

返回該類(lèi)所有的注解對(duì)象

getConstructor(Class...<?> parameterTypes)

獲得該類(lèi)中與參數(shù)類(lèi)型匹配的公有構(gòu)造方法

getConstructors()

獲得該類(lèi)的所有公有構(gòu)造方法

getDeclaredConstructor(Class...<?> parameterTypes)

獲得該類(lèi)中與參數(shù)類(lèi)型匹配的構(gòu)造方法

getDeclaredConstructors()

獲得該類(lèi)所有構(gòu)造方法

getMethod(String name, Class...<?> parameterTypes)

獲得該類(lèi)某個(gè)公有的方法

getMethods()

獲得該類(lèi)所有公有的方法

getDeclaredMethod(String name, Class...<?> parameterTypes)

獲得該類(lèi)某個(gè)方法

getDeclaredMethods()

獲得該類(lèi)所有方法

Field 類(lèi)

Field 類(lèi)提供類(lèi)或接口中單獨(dú)字段的信息，以及對(duì)單獨(dú)字段的動(dòng)態(tài)訪(fǎng)問(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 類(lèi)

invoke(Object obj, Object... args)

傳遞object對(duì)象及參數(shù)調(diào)用該對(duì)象對(duì)應(yīng)的方法

ClassLoader 類(lèi)

反射中，還有一個(gè)非常重要的類(lèi)就是 ClassLoader 類(lèi)，類(lèi)裝載器是用來(lái)把類(lèi)(class)?裝載進(jìn)?JVM的。ClassLoader 使用的是雙親委托模型來(lái)搜索加載類(lèi)的，這個(gè)模型也就是雙親委派模型。ClassLoader 的類(lèi)繼承圖如下

枚舉

枚舉可能是我們使用次數(shù)比較少的特性，在 Java 中，枚舉使用?enum?關(guān)鍵字來(lái)表示，枚舉其實(shí)是一項(xiàng)非常有用的特性，你可以把它理解為具有特定性質(zhì)的類(lèi)。enum 不僅僅 Java 有，C 和 C++ 也有枚舉的概念。下面是一個(gè)枚舉的例子。

public?enum?Family?{FATHER,MOTHER,SON,Daughter;}

上面我們創(chuàng)建了一個(gè)?Family的枚舉類(lèi)，它具有 4 個(gè)值，由于枚舉類(lèi)型都是常量，所以都用大寫(xiě)字母來(lái)表示。那么 enum 創(chuàng)建出來(lái)了，該如何引用呢？

public?class?EnumUse?{public?static?void?main(String[]?args)?{Family?s?=?Family.FATHER;} }

枚舉特性

enum 枚舉這個(gè)類(lèi)比較有意思，當(dāng)你創(chuàng)建完 enum 后，編譯器會(huì)自動(dòng)為你的 enum 添加?toString()?方法，能夠讓你方便的顯示 enum 實(shí)例的具體名字是什么。除了 toString() 方法外，編譯器還會(huì)添加?ordinal()?方法，這個(gè)方法用來(lái)表示 enum 常量的聲明順序，以及?values()?方法顯示順序的值。

public?static?void?main(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)入包可以做到不用輸入?枚舉類(lèi)名.常量，可以直接使用常量，神奇嗎? 使用 ennum 和?static?關(guān)鍵字可以做到靜態(tài)導(dǎo)入包

上面代碼導(dǎo)入的是 Family 中所有的常量，也可以單獨(dú)指定常量。

枚舉和普通類(lèi)一樣

枚舉就和普通類(lèi)一樣，除了枚舉中能夠方便快捷的定義常量，我們?nèi)粘ｉ_(kāi)發(fā)使用的?public static final xxx?其實(shí)都可以用枚舉來(lái)定義。在枚舉中也能夠定義屬性和方法，千萬(wàn)不要把它看作是異類(lèi)，它和萬(wàn)千的類(lèi)一樣。

public?enum?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;}public?void?setDescription(String?description)?{this.description?=?description;}public?static?void?main(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 }public?class?TrafficLight?{Signal?color?=?Signal.RED;public?void?change()?{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)。我們來(lái)看一下 Enum 類(lèi)，此類(lèi)位于?java.lang?包下，可以自動(dòng)引用。

此類(lèi)的屬性和方法都比較少。你會(huì)發(fā)現(xiàn)這個(gè)類(lèi)中沒(méi)有我們的 values 方法。前面剛說(shuō)到，values()?方法是你使用枚舉時(shí)被編譯器添加進(jìn)來(lái)的 static 方法。可以使用反射來(lái)驗(yàn)證一下。

除此之外，enum 還和 Class 類(lèi)有交集，在 Class 類(lèi)中有三個(gè)關(guān)于 Enum 的方法

前面兩個(gè)方法用于獲取 enum 常量，isEnum?用于判斷是否是枚舉類(lèi)型的。

枚舉類(lèi)

除了 Enum 外，還需要知道兩個(gè)關(guān)于枚舉的工具類(lèi)，一個(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ě)了大量的類(lèi)只為了能夠創(chuàng)建一個(gè)良好的工具包，想必編寫(xiě) I/O 工具包很費(fèi)勁吧。

IO 類(lèi)設(shè)計(jì)出來(lái)，肯定是為了解決 IO 相關(guān)操作的，最常見(jiàn)的 I/O 讀寫(xiě)就是網(wǎng)絡(luò)、磁盤(pán)等。在 Java 中，對(duì)文件的操作是一個(gè)典型的 I/O 操作。下面我們就對(duì) I/O 進(jìn)行一個(gè)分類(lèi)。

“

公號(hào)回復(fù)?IO獲取思維導(dǎo)圖

I/O 還可以根據(jù)操作對(duì)象來(lái)進(jìn)行區(qū)分：主要分為

除此之外，I/O 中還有其他比較重要的類(lèi)

File 類(lèi)

File 類(lèi)是對(duì)文件系統(tǒng)中文件以及文件夾進(jìn)行操作的類(lèi)，可以通過(guò)面向?qū)ο蟮乃枷氩僮魑募臀募A，是不是很神奇？

文件創(chuàng)建操作如下，主要涉及?文件創(chuàng)建、刪除文件、獲取文件描述符等

class?FileDemo{public?static?void?main(String[]?args)?{File?file?=?new?File("D:\\file.txt");try{f.createNewFile();?//?創(chuàng)建一個(gè)文件//?File類(lèi)的兩個(gè)常量//路徑分隔符(與系統(tǒng)有關(guān)的）<windows里面是?; linux里面是?：?>System.out.println(File.pathSeparator);??//???;//與系統(tǒng)有關(guān)的路徑名稱(chēng)分隔符<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)行操作

class?FileDemo{public?static?void?main(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類(lèi)的父路徑、子路徑 System.out.println(file3);

現(xiàn)在對(duì) File 類(lèi)進(jìn)行總結(jié)

基礎(chǔ) IO 類(lèi)和相關(guān)方法

雖然. IO 類(lèi)有很多，但是最基本的是四個(gè)抽象類(lèi)，InputStream、OutputStream、Reader、Writer。最基本的方法也就是?read()?和?write()?方法，其他流都是上面這四類(lèi)流的子類(lèi)，方法也是通過(guò)這兩類(lèi)方法衍生而成的。而且大部分的 IO 源碼都是?native?標(biāo)志的，也就是說(shuō)源碼都是 C/C++ 寫(xiě)的。這里我們先來(lái)認(rèn)識(shí)一下這些流類(lèi)及其方法

InputStream

InputStream 是一個(gè)定義了 Java 流式字節(jié)輸入模式的抽象類(lèi)。該類(lèi)的所有方法在出錯(cuò)條件下引發(fā)一個(gè)IOException 異常。它的主要方法定義如下

OutputStream

OutputStream 是定義了流式字節(jié)輸出模式的抽象類(lèi)。該類(lèi)的所有方法返回一個(gè)void 值并且在出錯(cuò)情況下引發(fā)一個(gè)IOException異常。它的主要方法定義如下

Reader 類(lèi)

Reader 是 Java 定義的流式字符輸入模式的抽象類(lèi)。類(lèi)中的方法在出錯(cuò)時(shí)引發(fā)?IOException?異常。

Writer 類(lèi)

Writer 是定義流式字符輸出的抽象類(lèi)。所有該類(lèi)的方法都返回一個(gè) void 值并在出錯(cuò)條件下引發(fā) IOException 異常

InputStream 及其子類(lèi)

FileInputStream 文件輸入流：FileInputStream 類(lèi)創(chuàng)建一個(gè)能從文件讀取字節(jié)的 InputStream 類(lèi)

ByteArrayInputStream 字節(jié)數(shù)組輸入流?：把內(nèi)存中的一個(gè)緩沖區(qū)作為 InputStream 使用

PipedInputStream 管道輸入流：實(shí)現(xiàn)了pipe 管道的概念，主要在線(xiàn)程中使用

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ù)類(lèi)型。

PushbackInputStream 推回輸入流：緩沖的一個(gè)新穎的用法是實(shí)現(xiàn)推回 （pushback）?。Pushback 用于輸入流允許字節(jié)被讀取然后返回到流。

OutputStream 及其子類(lèi)

FileOutputStream 文件輸出流：該類(lèi)實(shí)現(xiàn)了一個(gè)輸出流，其數(shù)據(jù)寫(xiě)入文件。

ByteArrayOutputStream 字節(jié)數(shù)組輸出流?：該類(lèi)實(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 基本類(lèi)型輸出流??：該類(lèi)將實(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ù)類(lèi)型。

Reader 及其子類(lèi)

FileReader 文件字符輸入流?：把文件轉(zhuǎn)換為字符流讀入

CharArrayReader 字符數(shù)組輸入流?：是一個(gè)把字符數(shù)組作為源的輸入流的實(shí)現(xiàn)

BufferedReader 緩沖區(qū)輸入流?：BufferedReader 類(lèi)從字符輸入流中讀取文本并緩沖字符，以便有效地讀取字符，數(shù)組和行

PushbackReader: PushbackReader 類(lèi)允許一個(gè)或多個(gè)字符被送回輸入流。

PipedReader 管道輸入流：主要用途也是在線(xiàn)程間通訊，不過(guò)這個(gè)可以用來(lái)傳輸字符

Writer 及其子類(lèi)

FileWriter 字符輸出流?：FileWriter 創(chuàng)建一個(gè)可以寫(xiě)文件的 Writer 類(lèi)。

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 管道輸出流：主要用途也是在線(xiàn)程間通訊，不過(guò)這個(gè)可以用來(lái)傳輸字符

Java 的輸入輸出的流式接口為復(fù)雜而繁重的任務(wù)提供了一個(gè)簡(jiǎn)潔的抽象。過(guò)濾流類(lèi)的組合允許你動(dòng)態(tài)建立客戶(hù)端流式接口來(lái)配合數(shù)據(jù)傳輸要求。繼承高級(jí)流類(lèi) InputStream、InputStreamReader、 Reader 和 Writer 類(lèi)的 Java 程序在將來(lái) （即使創(chuàng)建了新的和改進(jìn)的具體類(lèi)）也能得到合理運(yùn)用。

注解

Java?注解（Annotation）?又稱(chēng)為元數(shù)據(jù)?，它為我們?cè)诖a中添加信息提供了一種形式化的方法。它是 JDK1.5 引入的，Java 定義了一套注解，共有 7 個(gè)，3 個(gè)在?java.lang?中，剩下 4 個(gè)在?java.lang.annotation?中。

作用在代碼中的注解有三個(gè)，它們分別是

• @Override：重寫(xiě)標(biāo)記，一般用在子類(lèi)繼承父類(lèi)后，標(biāo)注在重寫(xiě)過(guò)后的子類(lèi)方法上。如果發(fā)現(xiàn)其父類(lèi)，或者是引用的接口中并沒(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ò)反射訪(fǎng)問(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（類(lèi)、接口、枚舉、Annotation類(lèi)型）、類(lèi)型成員（方法、構(gòu)造方法、成員變量、枚舉值）、方法參數(shù)和本地變量（如循環(huán)變量、catch參數(shù)）。取值如下

public?enum?ElementType?{TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE,ANNOTATION_TYPE,PACKAGE,TYPE_PARAMETER,TYPE_USE

• @Inherited?：標(biāo)記這個(gè)注解是繼承于哪個(gè)注解類(lèi)的。

從 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 是任何引用類(lèi)型的初始值

null 是所有引用類(lèi)型的默認(rèn)值，Java 中的任何引用變量都將null作為默認(rèn)值，也就是說(shuō)所有 Object 類(lèi)下的引用類(lèi)型默認(rèn)值都是 null。這對(duì)所有的引用變量都適用。就像是基本類(lèi)型的默認(rèn)值一樣，例如 int 的默認(rèn)值是 0，boolean 的默認(rèn)值是 false。

下面是基本數(shù)據(jù)類(lèi)型的初始值

null 只是一種特殊的值

null 既不是對(duì)象也不是一種類(lèi)型，它僅是一種特殊的值，你可以將它賦予任何類(lèi)型，你可以將 null 轉(zhuǎn)換為任何類(lèi)型

public?static?void?main(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)換成任何的引用類(lèi)型都是可行的，并且不會(huì)拋出空指針異常。

null 只能賦值給引用變量，不能賦值給基本類(lèi)型變量。

持有 null 的包裝類(lèi)在進(jìn)行自動(dòng)拆箱的時(shí)候，不能完成轉(zhuǎn)換，會(huì)拋出空指針異常，并且 null 也不能和基本數(shù)據(jù)類(lèi)型進(jìn)行對(duì)比

public?static?void?main(String[]?args)?{int?i?=?0;Integer?itr?=?null;System.out.println(itr?==?i); }

使用了帶有 null 值的引用類(lèi)型變量，instanceof?操作會(huì)返回 false

public?static?void?main(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ì)類(lèi)型強(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 類(lèi)庫(kù)中有很多工具類(lèi)都提供了靜態(tài)方法，例如基本數(shù)據(jù)類(lèi)型的包裝類(lèi)，Integer , Double 等。例如

public?class?NullSafeMethod?{private?static?String?number;public?static?void?main(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，如下所示：

public?class?CompareNull?{private?static?String?str1;private?static?String?str2;public?static?void?main(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

?

《新程序員》：云原生和全面數(shù)字化實(shí)踐50位技術(shù)專(zhuān)家共同創(chuàng)作，文字、視頻、音頻交互閱讀

總結(jié)

以上是生活随笔為你收集整理的我肝了一个月，给你写出了这本Java开发手册。的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。