Java基礎知識點總結

Java基礎知識總結

配置環境變量：

語言基礎

循環結構

函數(方法)

數組

面向對象

面向對象三大特性

三個修飾符

接口

常用類

集合框架

異常

I/O框架

多線程

反射

配置環境變量：

在系統配置中新建

變量名：“JAVA_HOME”

變量值：“C:\Program Files (x86)\Java\jdk1.6.0_21”(jdk安裝路徑)

在系統配置中新建

變量名：“CLASSPATH”

變量值："."

在系統變量中編輯Path變量

添加"%JAVA_HOME%\bin;" //注意：加分號結束

測試：運行–> cmd -->java/ javac命令回車，看到配置信息為正確(java -version查看jdk版本)

提示：“不是內部或外部指令”為失敗

語言基礎

一、HelloWorld：Class–>班級 Java中Class–>類

創建以.java結尾的源文件。

class：類（代碼的容器）。

main：主函數，程序執行的入口，一個類當中，只能有一個主函數。

一行只寫一句代碼，以 ; 結束。

Writer once Run anywhere

JVM（Java Virtual Machine）Java虛擬機 VM Virtual Box

二、編譯、運行：

編譯：javac 源文件名稱.java 例：javac A.java --> HelloWorld.class

運行：java 類名 例：java HelloWorld

三、類的基本闡述：

在一個源文件中，可以定義多個類，編譯后，每個類都會生成獨立的 字節碼文件。

在一個類中，只能有一個主函數。

公開類（public class）的類名要和文件名完全相同。

在一個源文件中，只能有一個公開類。

四、Package（包）：

作用：管理類、區分類。

語法：package 包名;（必須在源文件的首行）

帶包編譯：javac -d . 源文件名稱.java（自動生成目錄結構）

帶包運行：java 包名.類名 （全限定名）

采用域名倒置的規則：http://www.yangxianyang.top

top.yangxianyang.java.class63.group1.project2.utility

五、編碼規范：

良好的注釋習慣：

I. 注釋不參與編譯。

II. 單行注釋： //單行

III. 多行注釋： /* 多行 /

IV. 文檔注釋： /* 文檔 */ javadoc指令生成外部說明文檔

例：javadoc -d . 源文件名稱.java

良好的標識符命名規范：

I. 硬性：

1). 數字、字母、_ 、$ ，數字不能開頭。

2). 不能與關鍵字、保留字重名。

II. 軟性：（約定俗成）

1). 望文生義、見名知義。

2). 類名可以由一個或多個單詞組成，每個單詞的首字母大寫 （Pasacl帕斯卡命名法）

3). 函數、變量由一個或多個單詞組成，首單詞首字母小寫，拼接 詞首字母大寫（Camel駝峰命名方法）

4). 包名全小寫，只能用特殊字符" . “，并且不能以”.“開頭或結尾。

5). 常量全大寫，多個單詞通過”_"拼接。

bit Byte KB MB GB TB PB EB ZB YB BB NB CB XB

六、變量：

一個存儲空間的表示，也是存儲數據的基本單元。

語法：

I. 聲明：數據類型 變量名;

賦值：變量名 = 值;

II. 聲明并賦值：數據類型 變量名 = 值;

III. 同時聲明多個變量：數據類型 名1,名2,名3=值;

七、數據類型：HotSpot 1.3.1 iadd isub imul idiv badd bsub

基本數據類型（原始、簡單）：8種

I. 整數：

1). byte 1個字節 -2^7 ~ 2^7-1 -128 ~ 127 0111 1111

2). short 2個字節 -2^15 ~ 2^15-1 -32768 ~ 32767

3). int 4個字節 -2^31 ~ 2^31-1 -2147483648 ~ 2147483647

4). long 8個字節 -2^63 ~ 2^63-1 “add L”

II. 小數（浮點）：近似值（1bit符號位、8bits指數位、23bits尾數位）

1). float 4個字節 1.4E-45 ~ 3.4E38 add F IEEE754標準

2). double 8個字節 4.9E324 ~ 1.7E308

III. 字符：無符號數（取值范圍從0 ~ 65535）

1). char 2個字節 \u0000 ~ \uFFFF ‘A’ 65 ‘\u0041’ ASCII編碼

2). 轉義字符： \t \n \ ’ "

IV. 布爾：

1). boolean 取值范圍：true / false

引用數據類型（對象）：N種

I. 字符串：String “abc” “HelloWorld”

八、類型轉換：

自動類型轉換：

I. 兩種類型相互兼容。

II. 目標類型大于源類型。

強制類型轉換：

I. 整數長度合適，數據完整。

II. 整數長度不適，數據截斷。

III. 小數強轉整數，失去精度，如，整數長度不適，則再次數據截斷。

IV. 字符整數互轉，數據完整，如，整數為負數，則轉型成"?"

V. boolean的取值只有true、false，無法轉換。

九、表達式：

概念：使用運算符連接的變量或字面值，并可以得到一個最終結果。

自動類型提升：

I. 兩個操作數，有一個為double，其結果提升為double。

II. 如果沒有double，有一個為float，其結果提升為float。

III. 如果沒有float，有一個為long，其結果提升為long。

IV. 如果沒有long，有一個為int，其結果提升為int。

V. 如果沒有int，也會自動提升為int。

VI. 任何類型與String相加（+）時，實為拼接，則提升為String。

十、運算符：

算數運算符：+ - * / % ++ –

賦值運算符：= += -= *= /= %= …

關系運算符：> < >= <= == !=

邏輯運算符：

I. && 與（并且）：兩個條件同時為真，結果為真。（短路）

II. || 或（或者）：兩個條件有一個為真，結果為真。（短路）

III. ! 非（不是）：取反。

三元運算符：布爾表達式? 結果1 : 結果2;

十一、控制臺輸入：

導包：import java.util.Scanner;

創建Scanner變量并賦值：Scanner input = new Scanner(System.in);

通過控制臺獲取不同內容：

I. nextInt(); //獲取整數

II. nextDouble(); //獲取小數

III. next(); //獲取字符串

IV. next().charAt(0); //獲取單個字符

注：如果輸入了不匹配的數據，java.util.InputMismatchException

十二、選擇結構：

基本if選擇結構：

if(布爾表達式){

//表達式結果為true，則執行此代碼塊

}

if else選擇結構：

if(布爾表達式){ //程序猿、程序媛

//表達式結果為true，則執行此代碼塊

}else{

//否則，執行此代碼塊

}

多重if選擇結構：

if(布爾表達式){

}else if(布爾表達式){

}else if(布爾表達式){

}else{}

注：相互排斥，當有一個條件被滿足時，其他均不再執行。適用于區 間判斷，保證升降的書寫順序。

十三、分支結構：

switch分支：

switch(byte、short、int、char){ //JDK7之后可以判斷String

case 1:

//執行代碼

break;

case N:

//執行代碼

break;

default:

//執行代碼

break;

}

break關鍵字：中斷、中止、跳出當前swithc分支結構。

注：適用于等值判斷，所有case的選項不可重復，并不會在滿足某個 選項后自動跳出switch，必須手動添加break中斷。

十四、局部變量：

概念：聲明在函數內部的變量，必須先賦值再使用。

作用范圍：定義行開始到包含它的代碼塊結束。

命名沖突。

循環結構

一、循環：

概念：通過某個條件，使一段代碼周而復始的執行。

組成：初始部分、循環條件、循環操作、迭代部分。

分類：

I. while循環：

while(布爾表達式){

}

特點：先判斷，再執行。

應用場景：循環次數明確。

例：1、2、3、4、5 ~ 100總和的統計

II. do while循環：

do{

}while(布爾表達式);

特點：先執行，再判斷。

應用場景：循環次數不明確。

例：先完成作業，再檢查結果。

III. for循環【重點】：

for(1.初始部分; 2.循環條件; 4.迭代部分){

//3.循環操作

}

特點：先判斷，再執行。

應用場景：循環次數明確。

例：階乘。

二、流程控制語句：

break：中止、跳出switch或循環結構。

continue：結束本次、進入下一次循環。

三、嵌套循環：

概念：在一個完整的循環結構當中，嵌套另一個完整的循環結構。

圖形：外層控制行數，內層控制列數。

其他：外層控制循環次數，內層控制單次循環操作。

函數(方法)

一、概念：實現特定功能一段代碼，可反復使用。

二、語法：

public static 返回值類型 函數名稱( 形式參數列表 ){

//函數主體

[ return value; ] //返回值

}

三、組成：

函數名稱：望文生義（camel命名法）

函數主體：邏輯代碼，完成特定功能。

形式參數：即是函數的局部變量，可聲明0~N個，調用時完成賦值。

返回值類型：基本數據類型、引用數據類型、void。

返回值：

return value;//結束當前函數，并伴有返回值，返回到函數調用處。

return;//單獨出現，只代表結束當前函數，返回到函數調用處。

規定：一個函數只能有一個返回值，至多是一個返回值。

注意：當函數存在分支語句時，要保證所有分支都具有正確的返回 值。

四、調用：

無參調用：函數名稱();

有參調用：函數名稱(實際參數…);//為形參賦予實際的值，類型、個數、 順序必須與形參列表完全匹配。

數據接收：數據類型 變量名 = 函數名稱(實參列表); //當所調用的函 數具有返回值時，可通過聲明與返回值類型匹配的變量進行接收。

執行機制：調用函數時，程序會跳轉到函數的定義位置，并優先執行 函數內部內容；執行完畢之后，會攜帶返回值，返回到函數調用位置。

五、總結：

一個類中可以定義多個函數，函數之間屬于并列關系，不可嵌套。

一個函數只做一件事兒。（單一職能原則）//粒度

減少冗余代碼、提高復用性、提高可讀性、提高可維護性、方便協同 合作。

六、遞歸：

將大問題拆分成小問題，解決方案一致，有固定的規律，則可實現遞歸。

函數自己調用自己（每調用一次，等于重新調用了另外一個函數）。

遞歸中一定包含判斷表達式，設定出口條件，否則產生無窮遞歸。

StackOverflowError //JVM棧空間溢出錯誤

數組

一、概念：一組連續的存儲空間，存儲多個相同數據類型的值。

二、語法：

數據類型[] 數組名; //聲明數組

數組名 = new 數據類型[ 長度 ]; //分配空間

數據類型[] 數組名 = new 數據類型[ 長度 ]; //聲明并分配空間

數據類型[] 數組名 = new 數據類型[]{值1,值2,值3,…} //顯示初始化

數據類型[] 數組名 = {值1,值2,值3,…} //顯示初始化（不能分行書寫）

三、訪問：

index（索引、下標），有效值：0 ~ length - 1

數組名[下標] ，進行數組元素的訪問。

長度：數組名.length //動態獲取長度。

遍歷：從頭到尾逐一訪問數組的元素。

注意：避免數組下標越界錯誤（java.lang.ArrayIndexOutOfBoundsException）

四、默認值：

int 0

double 0.0

boolean false

chara \u0000

String null （所有的引用數據類型，默認值都是null）

五、應用：

統計一組元素的總和。

數組擴容：

I. 聲明：在原數組長度的基礎之上，重新聲明新數組。

II. 賦值：（復制）

1). 通過循環將原數組中的每個元素，依次復制給新數組的每個元 素。

2). System.arraycopy(原數組名,原數組起始下標,新數組名,新數組起 始位置,長度);

3). dataType[] java.util.Arrays.copyOf(原數組名,新長度);

增刪元素：

I. 將插入位置起的所有元素，依次后移一位。

II. 將刪除位置后的所有元素，依次前移一位。

六、排序：

冒泡排序：相鄰的兩個數值比較大小、互換位置（升序：前小后大）

規則：外層length-1，內層length-1-i

選擇排序：固定值和其他值依次比較大小，互換位置。

規則：內層 int j = i + 1;

快速排序：java.util.Arrays.sort(數組名); //JDK提供（只能做升序）

規則：如需降序，自行實現reverse

七、二維數組：

概念：一維數組的一維數組，一維數組的元素，還是數組。

語法：

I. 數據類型[][] 數組名;

數組名 = new 數據類型[高維長度][低維長度];

II. 數據類型[][] 數組名 = new 數據類型[高維長度][];//不規則矩形

注意：低維數組必須自行通過new語句創建。

III. 數據類型[][] 數組名;

數組名 = new 數據類型[][]{ {v1,v2,v3},{v4,v5},{v6,v7,v8,v9} };

面向對象

一、面向對象思想（Object Oriented Programming）：

一切客觀存在的事物都是對象，萬物皆對象。

對象一定具有自己的特征（屬性）和行為（方法）。

二、類：

概念：

I. 在一組相同或類似的對象中，抽取出共性的特征和行為。

II. 類是對象的模板。

現實生活中的對象–（抽象）–>程序中的模板（類）–>

創建程序中的對象–>解決現實問題

類是對象的抽象，對象是類的實例

組成：

I. 屬性：（代表對象有什么）

1). 實例變量（成員變量）:聲明在類的內部，函數的外部，當通過 類構建對象的同時，所有成員變量都成為當前對象不可分割的 特征。

2). 語法：數據類型 屬性名;

局部變量 成員變量

定義位置 函數或函數中的結構中 類的內部、函數的外部

默認值 無 字面常量（與數組相同）

使用范圍 從定義行到代碼塊結束 本類有效

命名沖突 不允許與局部變量重名 可與局部變量重名，但局部變量優先

注：如成員變量的聲明和賦值分開完成，則賦值語句必須在函數內部。

II. 方法：（代表對象能做什么）

訪問修飾符 返回值類型 方法名稱( 形式參數列表 ){

//方法主體

[return value;] //返回值

}

III. 方法重載（Overload）：

1). 概念：方法名稱相同、參數列表不同（類型、個數、順序）。

2). 屏蔽使用的差異、靈活、便利。

IV. 構造方法（Constructor）：

1). 沒有返回值類型。

2). 構造方法名稱必須與類名完全相同。

3). 創建對象時，觸發構造方法的調用，不可通過句點手動調用。

4). 注意：

a. 在類中，如沒有顯示定義構造方法，則編譯器默認提供無參 構造方法。

b. 如顯示定義過構造方法，則無參構造方法不再默認提供。

c. 構造方法可以重載，遵循重載規則。

d. 通過關鍵字new對象時，根據傳入不同的參數，調用對應的 構造方法，完成對象的創建。

e. 有參構造方法可在創建對象的同時，為各個屬性賦值，或完 成必要的初始行為。

三、對象：

概念：

I. 具有多個特征和行為的實體。

II. 對象是類的實例。

創建對象：

I. 語法：數據類型 對象名 = new 數據類型();

II. 空間的分配：棧分配局部變量空間，堆分配對象空間。

III. 屬性默認值：基本為對應的零值，引用為null。

四、訪問屬性和方法：

引用（存儲對象的局部變量）中保存的是對象的具體地址。（reference）

通過引用訪問對象的屬性和方法：

Dog d1 = new Dog();

d1.breed = “拉布拉多”;//賦值

d1.breed //取值

d1.eat(); //調用方法

五、this關鍵字：

當前實例，當成員變量與局部變量重名時，如需使用成員變量，應增 加this.前綴。例如：this.name this.age

通過this()或this(實參)調用本類中的其他構造方法，但必須是構造方 法的首行。

構造方法之間可以相互調用，但最終產生的對象只有一個。每new一 次，只有一個對象。

六、數據的傳遞（賦值）：

值傳遞：基本數據類型，傳遞的是值，一方改變不會影響另乙方。

引用傳遞：引用數據類型，傳遞的是地址，一方改變另一方也會變。

面向對象三大特性

一、封裝：

概念：盡可能的隱藏類的內部實現細節，從而控制用戶對類的修改及 訪問的權限。

實現步驟：

I. 私有屬性：private修飾屬性名稱。

II. 訪問方法：public修飾setXXX()、getXXX()方法。

訪問形式：

I. 封裝前：

1). 賦值：s1.age = 30000;

2). 取值：s1.age

II. 封裝后：

1). 賦值：s1.setAge(30000);

2). 取值：s1.getAge();

二、繼承：

概念：類與類滿足is a的關系，子類（派生類）是一種父類（超類、 基類）。

父類的抽象：

I. 父類：在一組相同或類似的類中，抽取共性的特征和行為。

II. 功能越精細、重合點越多，越貼近直接父類。

III. 功能越粗略、重合點越少，越貼近Object類。

IV. 將多個子類中共性的特征和行為，定義在父類中實現重用。

繼承語法：子類 extends 父類{}

產生繼承關系后，子類可以使用父類中所聲明的屬性和方法，也可定 義子類獨有的屬性和方法。

Java為單繼承：一個類只能有一個直接父類，但可以多級繼承。

不可繼承：

I. private修飾的私有屬性和方法。

II. 構造方法。

III. 非同包時，由default修飾的屬性和方法。

訪問修飾符（訪問可見性）：

本類 同包 非同包 子類 其他

private yes

default yes yes

protected yes yes yes

public yes yes yes yes

注意：default：管理的范圍是包（package），只要在同一個包中即可 訪問。

方法覆蓋（Override 重寫）：

I. 當父類提供的方法無法滿足子類需求時，可在子類中聲明和父類完 全相同的方法進行覆蓋。

II. 子類覆蓋父類方法后，在實際調用中，優先調用子類覆蓋后的方法。

III. 子類覆蓋父類方法時，訪問修飾符必須與父類相同或比父類更寬 泛。

super關鍵字：

I. 在子類中，可以通過super.訪問父類中所定義的屬性和方法。

II. super()或super(實參)在子類構造方法中，顯示調用父類構造方法， 但必須是構造方法的首行。

III. 子類構造方法中如沒有顯示調用父類構造方法，則編譯器默認提供 super()，調用父類無參構造方法。

繼承關系的初始化：構造子類對象時，先構建父類對象

I. 分配空間。

II. 初始化父類屬性

III. 執行完畢父類構造方法

IV. 初始化子類屬性

V. 執行完畢子類構造方法

三、多態：

概念：父類引用指向子類對象，從而產生多種形態。

語法：父類類型 引用名稱 = new 子類類型();

注：僅可調用父類中所聲明的屬性和方法、而不可調用子類獨有的屬 性和方法。

應用方式（1.繼承、2.覆蓋）：

I. 使用父類作為方法形參，實現多態。（可以讓一個方法的參數類型 的個數更寬泛）

II. 使用父類作為方法返回值，實現多態。（返回值可以是任意子類類 型）

作用：

I. 屏蔽子類間的差異。

II. 靈活、耦合度低。

對象間的類型轉換：

I. 父類引用中保存子類的真實實例，稱為向上轉型（裝箱）。

例如：Animal a = new Dog(); Vehicle veh = new Bus();

II. 將父類引用中的真實子類實例，強制轉換回其本身類型，稱為向下 轉型（拆箱）

例如：Dog dog = (Dog)a; Bus bus = (Bus)veh;

III. 向下轉型時，如子類真實類型與目標類型不匹配，則發生類型轉換 異常（ClassCastException）

instanceof關鍵字：

I. 語法：父類引用 instanceof 子類類型

II. 語義：布爾表達式判斷引用中的對象是否與子類類型匹配

三個修飾符

一、static（靜態）：

概念：

I. static修飾符表示類成員、全類所有對象共享的成員。

II. 不必創建對象，可直接通過類名調用。

靜態屬性、靜態方法（類屬性、類方法）：

I. 全類共享（不屬于某一個對象）。

II. 訪問方式：類名.靜態成員名稱。

//Math.random()、Math.sqrt()、System.out、Arrays.copyOf()、 Arrays.sort()、System.arraycopy()

III. 所有引用調用的靜態屬性和方法都會自動轉換成類名調用。

靜態方法可以繼承，沒有多態。

靜態方法不能直接訪問非靜態的成員：

I. 原因1：當訪問靜態方法時，可能還沒有對象的產生。

II. 原因2：實例屬性和方法都默認擁有this前綴，代表當前實例，然 而靜態方法不屬于某個實例。

靜態代碼塊：

I. 類加載時被執行一次，不能手動調用。

II. 類加載（ClassLoading）：

1). JVM首次使用（new對象、調用靜態成員、使用子類時、 Class.forName(“全限定名”);）某個類時，通過CLASSPATH查找該 類的.class文件。

2). 將.class文件中所有的描述信息（屬性、方法、構造方法）加載 到內存中，進行保存。

3). 優先加載，可為靜態屬性賦值，或任何程序必要的初始行為。

類加載以及創建對象的十步操作：

I. 類級別：

1). 父類靜態屬性

2). 父類靜態代碼塊

3). 子類靜態屬性

4). 子類靜態代碼塊

II. 對象級別：

5). 父類實例屬性

6). 父類動態代碼塊

7). 父類構造方法

8). 子類實例屬性

9). 子類動態代碼塊

10).子類構造方法

二、abstract（抽象）：

修飾類：不能new對象（往往父類是不該被創建成對象的）。

修飾方法：只有方法聲明，沒有方法實現的（必須包含在一個抽象類 中）

注意：

I. 抽象類中不一定有抽象方法，有抽象方法的類一定是抽象類。

II. 子類繼承抽象類后，必須實現父類中所有的抽象方法，否則子類還 是抽象類。

三、final（最終）：

修飾類：此類不能被繼承。（String、Math、System）

修飾方法：此方法不能被覆蓋。

修飾變量：此變量的值不可改變（常量）。

I. 沒有初始值，必須手動賦值。

II. 實例常量：顯示初始化、動態代碼塊、構造方法（創建對象完成前）

III. 靜態常量：顯示初始化、靜態代碼塊（類加載完成前）

IV. 常用public static final聯合修飾的變量，稱為公開靜態常量。

V. 基本數據類型：值不可變；引用數據類型：地址不可變。

接口

一、概念：相當于特殊的抽象類，接口是一種能力，接口是一種約定。(抽象類的抽象)

二、語法：

定義接口：interface 接口名稱{}

實現接口：implements 接口名稱{}

三、與抽象類的異同：

I. 相同：

1). 不能new對象。

2). 都可以編譯成字節碼文件。

3). 都可以作為引用類型。

II. 不同：

1). 所有屬性都是公開靜態常量，隱式使用public static final修飾。

2). 接口中所有方法都是公開抽象方法，隱式使用public abstract修飾

3). 沒有構造方法、沒有動態、靜態代碼塊。

四、關系：

類與類：單繼承

類與接口：多實現

接口與接口：多繼承

注意：一個類在繼承父類的同時，還可以實現多個接口。

五、規范：

任何類在實現接口的同時，必須實現接口中所有的抽象方法，否則該 類還是抽象類。

實現接口中的抽象方法，訪問修飾符必須是public。

六、應用場景：Java為單繼承，當父類提供的方法個數無法滿足子類需求時， 可以通過實現接口來擴充子類的能力。

七、接口引用：

接口引用指向實現類對象，僅可調用接口中所聲明的方法。

使用接口作為方法形參，可更自然的使用多態。

八、接口回調：先有接口的使用者，后有接口的實現者。

九、好處：

設計與實現完全分離。

更容易搭建程序框架。

更容易更換實現。

程序的耦合降低。

常用類

一、內部類：

概念：

I. 在類的內部再定義一個類。

II. 內部類編譯之后會生成字節碼文件。

III. 內部類可以訪問外部類的私有成員、而不破壞封裝。

分類：

I. 成員內部類【了解】：

1). 是外部類的一個部分，創建內部類對象時，必須依賴外部類對 象。

2). 可直接訪問外部類的私有成員。

3). 通過“外部類類名.this”訪問外部類的成員變量。

4). 語法：

a. 創建：

Outer out = new Outer();

Outer.Inner in = out.new Inner();

b. 訪問：

Outer.this.field //訪問外部類的成員變量

II. 靜態內部類【了解】：

1). 不依賴外部類對象，可直接創建內部類對象，或通過類名訪問 內部類的靜態成員。

2). 只能訪問外部類的靜態成員。

3). 語法：

a. 創建：

Outer.Inner in = new Outer.Inner();

b. 訪問：

Outer.field //直接訪問外部類靜態成員

III. 局部內部類【重要】：

1). 當訪問外部類的局部變量時，因無法保證二者的生命周期一致， 所以必須為局部變量增加final修飾符。

2). 作用范圍和創建對象的范圍僅在方法內部，隱藏類的信息。

IV. 匿名內部類【重要】：

1). 沒有類名的局部內部類。

2). 必須繼承一個父類或者實現一個接口。

3). 定義類、實現類、創建對象三步的語法合并。

4). 生命周期內只能創建一個對象。

API（Application Programming Interface）應用程序編程接口，幫助文檔。

二、Object類：

概念：

I. 超類、基類、所有類直接或間接的父類，位于繼承樹的頂層。

II. 任何類，如沒有書寫extends顯示繼承，則默認直接繼承Object。

III. Object所定義的方法，是所有對象有具有的方法。

IV. Object類型可以存儲任何對象，作為參數、可接收任何對象；作為 返回值，可返回任何對象。

方法：

I. public final Class getClass() //返回對象的運行時類型（真實類型）

比較兩個對象的真實類型是否一致 a1.getClass() == a2.getClass()

II. public int hashCode() //根據對象的物理地址、字符串、整數部分進 行計算，最終得到一個int類型的結果。哈希碼并不唯一，它是一 種算法，盡量保證不同對象返回不同哈希碼。

III. public String toString() //返回該對象的字符串表示。

可根據自己的業務需求，選擇性覆蓋父類中的toString()。

IV. public boolean equals(Object obj) //比較兩個對象是否相同

Object實現策略為“==”比較地址。

如需判斷地址不同，內容相同的兩個對象，則需要自行覆蓋。

V. protected void finalize() ：

I. 垃圾回收：銷毀垃圾對象，釋放存儲空間。

II. 垃圾對象：沒有任何引用指向對象，為垃圾對象。

III. 垃圾收集器（Garbage Collect）:

自動：JVM內存耗盡，自動回收。

手動：System.gc()，通知JVM執行回收（優先級較低）。

三、包裝類：

概念：

I. 8種基本數據所對應的引用數據類型。

II. Object可統一所有數據，默認值為null。

匹配：

byte —> Byte

short —> Short

int —> Integer

long —> Long

float —> Float

double —> Double

char —> Character

boolean —> Boolean

類型轉換：

I. Number父類中繼承到的6個轉型方法。

II. 構造方法。

III. parseXXX(String s) //靜態方法，將字符串轉換成基本類型

IV. valueOf() //靜態方法，將基本或字符串轉換成包裝類型

V. 注意兼容類型，避免NumberFormatException異常。

VI.JDK5之后，自動裝箱、拆箱。包裝類型與基本類型可自動轉換。

四、String：

概念：

I. 字符串是常量，創建之后不可改變。

II. 字符串字面值存儲在字符串池中，可以共享。

創建：

String s1 = “abc”;

String s2 = new String(“abc”);

方法：

public char charAt(int index) //返回index所對應的字符

public String concat(String str)

public boolean contains(CharSequence s) // CharSequence就是字符串 String

public boolean endsWith(String suffix)

public boolean startsWith(String suffix)

public int indexOf(String str)

public int lastIndexOf(String str)

public String replace(char oldChar,char newChar)

public String[] split(String regex)

public String substring(int beginIndex)

public String toLowerCase() //將字符串轉換成大寫

public String toUpperCase()

public String trim()

可變字符串：

I. StringBuffer：JDK1.0推出，操作速度慢、線程安全。

II. StringBuilder：JDK5推出，操作速度快、線程不安全。

III. 常用方法：append(?); //追加

集合框架

一、概念：

對象的容器，存儲對象的對象，大多數情況下，可代替數組。

位置：java.util.*;

結構：

二、Collection體系集合詳解：

Collection父接口：

I. 特點：存儲所有Object數據。

II. 方法：

boolean add(Object o) //向集合中添加一個對象

void clear() //清空集合中的對象

boolean contains(Object o) //檢查集合中是否包含o對象

boolean remove(Object o) //將o對象從集合中移除

int size() //返回集合中元素的個數

Object[] toArray() //將集合轉換成Object數組。

List子接口：for、forEach、Iterator

I. 特點：有序、有下標、元素可以重復。

II. 方法：

void add(int index, E element) //在指定位置插入元素

E get(int index) //返回指定位置的元素

E remove(int index) //通過下標移除元素

E set(int index, E element) //在指定位置替換元素

List subList(int fromIndex,int toIndex) //返回fromIndex與toIndex 之間的元素

III. 實現類：

1). ArrayList【重點】：

a. 數組結構存儲。

b. JDK 1.2推出 操作速度快，線程不安全。

c. 查詢快、增刪慢。

2). Vector【了解】：

a. 數組結構存儲。

b. JDK 1.0推出 操作速度慢，線程安全。

3). LinkedList【了解】：

a. 鏈表結構存儲。

b. 查詢慢、增刪快。

c. 實現棧Stack，Last In First Out(LIFO)后進先出

d. 實現隊列Queue，Last In Last Out(LILO)后進后出->先進先出

三、泛型集合【重點】：

參數化類型、類型安全的集合，限制元素的類型必須一致。

編譯期即可檢查數據類型。

訪問時，不必拆箱。

不同泛型之間不可相互賦值，泛型不存在多態。

E = Element / K = Key / V = Value / U = Utility Unit / R = Result / T = Type

四、Collections工具類：

public static void sort(List list) //升序排序

public static void reverse(List list) //倒置

public static void shuffle(List list) //亂序、洗牌

五、Set子接口：forEach、Iterator

特點：無序、無下標、元素不可重復。

方法：全部繼承自Collection。

實現類：

I. HashSet【重點】：

1). 將自定義類對象存入HashSet時，無法保證元素內容不重復。

2). 覆蓋equals方法，保證內容相同的對象，比較結果為true。

3). 為觸發equals的調用，必須覆蓋hashCode方法：

a. 確保相同對象返回相同哈希碼。

b. 盡量保證不同對象返回不同哈希碼。

II. LinkedHashSet【了解】：保留元素的插入順序。

III. TreeSet【了解】：

1). 實現了SortedSet接口，對集合元素自動排序。

2). 元素對象的類型必須實現Comparable接口中的compareTo方法， 指定排序的規則。

3). 希望this靠前，則返回負數；希望this靠后，則返回正數；返回 則代表相等。

4). TreeSet通過compareTo方法的結果進行排序，如果結果為“零”， 則可以指定次要排序列。

4. 迭代方式：

I. Iterator迭代器：

1). 獲取當前集合的專屬迭代器。

Iterator it = set.iterator();

2). 循環判斷是否存在下一個元素，并獲取下一個元素。

while(it.hasNext()){//判斷

it.next();//獲取

}

II. forEach遍歷：

for(數據類型 局部變量名 : 容器){

//將容器中的每個對象臨時保存在局部變量中

//循環體內容完成對當前對象的操作

}

六、Map接口：

特點：存儲一對數據（key-value），無序、無下標，鍵不能重復、值 可以重復。通過建訪問值（通過key訪問value）。

方法：

V put(K key, V value) //將關聯的鍵和值一并存儲

V get(Object key) //通過建訪問值

V remove(Object key) //通過鍵移除整個鍵值對

Set keySet() //獲取所有的鍵

Collection values() //獲取所有的值

Set entrySet() //獲取所有的鍵加值（格式為：“key=value”）

實現類：

I. HashMap【重點】：

1). 允許使用null作為key或value，重復鍵會覆蓋原有鍵值對。

2). JDK 1.2推出 操作速度快、線程不安全。

II. Hashtable【了解】：

1). 不允許使用null作為key或value。

2). JDK 1.0推出 操作速度慢、線程安全。

III. TreeMap【了解】：

1). 實現SortedMap接口，自動對key排序。

2). 作為key的對象，必須實現Comparable接口。

IV. Properties【了解】：

1). Hashtable的子類，存取時的參數必須是String類型。

2). 可以直接在流（IO）中加載內容。

異常

一、概念：程序在運行中發生的特殊情況。

二、異常分類：

Throwable：

|- Error：錯誤，硬件、JVM、執行邏輯錯誤，不能手動處理。

|- Exception：異常，程序在運行或配置中產生的問題，可處理。

|- RuntimeException：運行時異常，編譯期不檢查，可處理可不處理

|- CheckedException：受查異常，編譯期檢查，必須處理。

三、異常的產生：

自動拋出：程序在運行時遇到不符合規范的代碼或結果，則產生異常。

手動拋出：throw 異常對象;

異常產生的結果：相當于遇到了return語句，導致程序因異常而中止。

四、異常的傳遞：按照方法的調用鏈進行反向傳遞m3->m2->m1->main->JVM

五、異常的處理：

作用：發生異常時，為提高代碼的容錯性，避免程序中止，執行預判 的處理代碼。從而盡量減少程序因異常帶來的損失。

方式：

I. 消極處理：throws 聲明異常，修飾在方法參數列表的后端。

public void method() throws Exception{}

注：

顯示告知調用者，此方法可能出現的異常。

只有異常的傳遞，而沒有捕獲異常，程序仍舊會因異常而中 止。

II. 積極處理【重點】：捕獲、處理異常。

try{

//可能發生異常的代碼

}catch(Exception e){ //將捕獲到的異常對象賦值給局部變量e

e.getMessage(); //獲取異常發生的原因、消息

e.printStackTrace(); //打印堆棧跟蹤信息

//異常處理代碼

}finally{

//最終：無論是否發生異常，此代碼塊一定會執行。

//常用于釋放資源。

}

III. 常用異常結構：

1). try{}catch{}

2). try{}catch{}catch{}…

3). try{}catch{}finally{}

4). try{}catch{}catch{}…finally{}

5). try{}finally{}

六、自定義異常：

繼承Exception或Exception的子類，常用RuntimeException。

繼承受查異常之后，拋出的異常通常不直接處理，以throws聲明異常 的形式，告知調用者處理。

七、帶有異常聲明的方法覆蓋：

遵循覆蓋語法。

子類覆蓋父類帶有異常聲明的方法時，不可拋出比父類更寬泛的異常。

子類可以聲明的異常必須 <= 父類聲明的異常

I/O框架

一、流：（Input / Output）

概念：流（對象）是在內存與存儲設備之間傳輸數據的通道。

分類：

I. 方向：

1). 輸出流：用以將<內存>中的數據寫入到<存儲設備>中。

2). 輸入流：用以將<存儲設備>中的數據讀入到<內存>中。

II. 單位：

1). 字節流：可以讀寫所有數據。

2). 字符流：只能讀寫文本數據。

III. 功能：

1). 節點流：實際傳輸數據。

2). 過濾流：增強節點流功能（處理流、裝飾類）。

二、字節流：

字節流父類：

I. OutputStream（輸出流）

II. InputStream（輸入流）

字節節點流【重點】：

I. FileOutputStream：

public void wirte(int b) //一次寫一個字節

public void write(byte[] b) //一次寫多個字節（b.length個）

II. FileInputStream：

public int read() //一次讀一個字節

public int read(byte[] b) //一次讀多個字節（最多b.length個）

字節過濾流：

I. DataOutputStream / DataInputStream：

1). 直接讀寫8種基本數據類型。

2). 直接讀寫String。（writeUTF()、readUTF()）

II. BufferedOutputStream：

1). 緩沖流，提高IO效率，減少訪問硬盤的次數。

2). 數據存儲到緩沖區，關閉前，需使用flush或close一次性寫入 到文件中，并清空緩沖。

III. ObjectOutputStream / ObjectInputStream【重點】：

1). 讀寫對象（序列化、反序列化），要求對象必須實現 java.io.Serializable接口，以啟動序列化功能。

2). 序列化對象時，必須保證其所有屬性均可序列化。

3). transient修飾為臨時屬性，不參與序列化。

4). java.io.EOFException表示到達文件末尾，可處理。

三、字符編碼：

ISO-8859-1 除收錄ASCII外，還包括西歐、希臘、泰國、阿拉伯、 希伯來對應的文字符號。

UTF-8 針對Unicode的可變長字符編碼。

GB2312 簡體中文。陶喆（陶吉吉）

GBK 簡體中文擴充版。

BIG5 臺灣繁體中文。

注意：字符編碼和字符解碼不一致時，可能造成亂碼。

四、字符流：

字符流父類：

I. Wrietr（輸出流）

II. Reader（輸入流）

字符節點流【重點】：

I. FileWriter：

public void write(String str) //一次寫一個字符串

II. FileReader：

public int read() //一次讀一個字符

public int read(char[] c) //一次讀一組字符

字符過濾流：

I. PrintWriter / BufferedReader：緩沖流，支持一次寫一行、讀一行。

II. OutputStreamWriter / InputStreamReader：

橋轉換流：用以將字節流轉換成字符串，并設置編碼格式。

使用步驟：

I. 創建節點流。

II. [ 包裝過濾流 ]。

III. 讀寫數據。

IV. 關閉流。

五、File對象：

概念：File代表物理盤符下的一個文件或者文件夾。

方法：參考API。

I. public Files[] listFiles();//獲取當前路徑下的所有File對象。

II. public Files[] listFiles(FileFilter filter); //文件過濾器

FileFilter接口：

實現：boolean accept(File file) //使滿足條件的文件對象，出現在listFile() 方法的返回值中（File數組）。

多線程

一、進程：

概念：

I. 程序是靜止的概念，而進程是程序的實體，在CPU執行時，才被 賦予生命，只有當程序真正的running時，被稱為進程。

II. 在任何時間點、時間戳，只能有一個進程在執行，宏觀并行、微觀 串行。

二、線程：

概念：

I. 輕量級進程（Light Weight Process LWP），代表進程中一個單一的 順序控制流程。

II. CPU調用的基本單位是線程（調用某一進程中的某一線程）。

III. 在單個進程中“同時”運行多個線程完成不同的工作，交替執行， 稱為多線程。

組成：

I. CPU：操作系統分配時間片（Windows：520ms、Linux：5800ms）。

II. 數據：堆空間共享（對象），棧空間獨立（變量）。

III. 代碼：

1). 繼承Thread類：

a. 覆蓋run方法。

b. 創建子類對象： Thread t1 = new MyExtendsThread();

c. 啟動線程： t1.start();

2). 實現Runnable接口：

a. 覆蓋run方法。

b. 創建子類對象： Runnable r = new MyImplRunnable();

c. 創建線程對象： Thread t2 = new Thread?;

d. 啟動線程： t2.start();

3). 常用方法：（造成阻塞）

public static void sleep(long millis) //當前線程休眠

public static void yield() //放棄、讓出時間片

public final void join() //將其他線程加入到自身線程中，優先執行

三、線程同步【重點】：

線程不安全：當多線程并發訪問臨界資源時，如果破壞原子操作，可 能造成數據不一致。

I. 臨界資源：共享資源（同一對象）。

II. 原子操作：不可分割的多個步驟，被視為一個整體，其順序不可打 亂或缺省。

互斥鎖標記：每個對象都有一個互斥鎖標記，用來分配給線程的。

鎖池：每個對象都有一個鎖池，用來存儲等待該對象鎖標記的線程的

同步方式【重點】：

1). 同步代碼塊：

synchronized(臨界資源){ //可為臨界資源加鎖

//原子操作

}

2). 同步方法：

synchronized 返回值類型 方法名稱(形參列表){

//原子操作

}

注:在調用同步方法時，需要對象的鎖標記，而調用非同步方法時， 不需要鎖標記，可直接訪問。

ArrayList操作速度快，線程不安全（支持并發訪問，非同步方法）

Vector 操作速度慢，線程安全（同步方法）

synchronized add()

remove()

死鎖、生產者消費者、哲學家進餐

反射

一、概念：

類的對象：基于某個類new出來的一個實例，也稱為實例對象。new Dog

類對象：封裝了一個類的所有信息（包名、類名、父類、接口、屬性、 方法、構造方法…）。Student.class

注意：類對象就是一個.class文件，當中包含了一個類的所有信息！

獲取類對象：

//1.通過類型直接獲取類對象

Class c1 = Student.class;//類對象

//2.以靜態方法的形式獲取類對象

Class c2 = Class.forName(“ref.Student”);

//3.通過類的實例對象獲取類對象

Student stu = new Student();

Class c3 = stu.getClass();

反射的應用：

//1.獲取父類Class對象

Class superClass = c.getSuperclass();

//2.獲取所有接口的Class對象

Class[] interfaces = c.getInterfaces();

//3. 獲取所有公開的屬性（包括父類屬性）

Field[] fields = c1.getFields();

//4. 獲取所有自身聲明的屬性（包括私有）

Field[] fields = c1.getDeclaredFields();

//5. 獲取所有公開的方法（包括父類方法）

Method[] methods = c1.getMethods();

//6. 獲取所有自身聲明的方法（包括私有）

Method[] methods = c1.getDeclaredMethods();

//7.通過類對象創建實例對象

public Object newInstance()

//8.獲取單個公開方法（包括父類）

Method pm = c.getMethod(“方法名稱”,“可邊長形參類型”);

//9.獲取單個自身方法（包括私有）

Method sm = c.getDeclaredMethod(“方法名稱”,“可邊長形參類型”);

//8. 執行Method對象：

method.invoke(“此方法隸屬于的對象”,“可變長實參”);

四、單例模式：

概念：一個類，只能有一個對象。

實現方式：

I. 餓漢式（類加載時創建，天生線程安全）

II. 懶漢式（使用時創建，線程不安全，需添加同步）

`

Java 數據結構

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。