感謝尚硅谷宋紅康老師

第一次在B站上看見 宋紅康老師 的視頻，真的是不一樣感覺！不一樣的識訓！跟著你學習java編程方面知識有種隨其自然、水到成渠的感覺，謝謝您！宋紅康老師！
如果正在學習java小伙伴，推薦學習B站尚硅谷宋紅康老師視頻！（絕對沒有推銷，因為自己也不認識宋老師！只看過視頻！）

java學習導圖

提示：基礎程式設計與面向物件編程屬于Java基礎編程，而應用程式開發與java新特性屬于java高級編程，

一、java基本語法

1.關鍵字與識別符號

關鍵字
	定義:被Java語言賦予了特殊含義，用做專門用途的字串（單詞）
	特點:所有字母都是小寫
	舉例：int、float、double.....
保留字
	定義:先階段Java版本未使用，但以后版本可能會當關鍵字使用
	現有保留字:goto、const
識別符號
	定義:凡是自己起的名字都叫識別符號
	涉及結構:包名、類名、介面名、變數名、屬性名、常量名
	系統命名規則
		由26個英文字母大小寫、0-9、_與$組成
		數字不可以開頭
		不能與關鍵字與保留字同名、但可以包含關鍵字與保留字
		嚴格區分大小寫
		不能有空格
	命名規范
		包名:多單詞組成時，所有字母都小寫 xxxyyy
		類名、介面名:多單詞組成時，所有首字母都大寫  XxxYyy
		變數名、方法名:多單詞組成時，第一個單詞首字母小寫,其它單詞首字母都大寫 xxxYyyZzz
		常量:所有字母都大寫，多單詞組成時，加_連接 XXX_YYY

2.變數分類

變數分類
資料型別分類
	基本資料型別
		數值型
			整數型
				byte:一個位元組 -128-127
				short :兩個位元組
				int:四位元組(默認int型)
				long:八位元組(末尾加L)
			浮點數
				float：四位元組(末尾加F)
				double：八位元組(默認double型)
		字符型:char
		布爾型:boolean
	參考資料型別
		類
		介面
		陣列
所處位置分類
	成員變數
		實體變數(非static修飾)
		類變數(static修飾)
	區域變數
		形參
		方法區域變數
		代碼塊區域變數

定義變數格式
變數型別 變數名 = 變數值；
變數型別 變數名；變數名 = 變數值；

變數使用注意點

① 變數必須先宣告，后使用
② 變數都定義在其作用域內，在作用域內，它是有效的，換句話說，出了作用域，就失效了
③ 同一個作用域內，不可以宣告兩個同名的變數

基本資料變數運算規則

1. 自動型別轉換：

   結論：當容量小的資料型別的變數與容量大的資料型別的變數做運算時，結果自動提升為容量大的資料型別，

   byte 、char 、short --> int --> long --> float --> double

   特別的：當byte、char、short三種型別的變數做運算時，結果為int型

說明：此時的容量大小指的是，表示數的范圍的大和小，比如：float容量要大于long的容量

2. 強制型別轉換：

1.需要使用強轉符：()
2.注意點：強制型別轉換，可能導致精度損失，

3.運算子

算術運算子： + - + - * / % (前)++ (后)++ (前)-- (后)-- +
特別說明：
1.(前)++ :先自增1，后運算
(后)++ :先運算，后自增1
2.(前)-- :先自減1，后運算
(后)-- :先運算，后自減1
3.連接符：+：只能使用在String與其他資料型別變數之間使用，

賦值運算子：= += -= *= /= %=
特別說明：
1.運算的結果不會改變變數本身的資料型別
2.
開發中，如果希望變數實作+1的操作，有幾種方法？(前提：int num = 10;)
//方式一：num = num + 1;
//方式二：num += 1;
//方式三：num++; (推薦)

比較運算子： == != > < >= <= instanceof
特別說明：
1.比較運算子的結果是boolean型別
2.> < >= <= :只能使用在數值型別的資料之間，
3. == 和 !=: 不僅可以使用在數值型別資料之間，還可以使用在其他參考型別變數之間，

邏輯運算子：& && | || ! ^
特別說明的：
1.邏輯運算子操作的都是boolean型別的變數，而且結果也是boolean型別

2.區分& 與 &&
相同點1：& 與 && 的運算結果相同
相同點2：當符號左邊是true時，二者都會執行符號右邊的運算
不同點：當符號左邊是false時，&繼續執行符號右邊的運算，&&不再執行符號右邊的運算，
開發中，推薦使用&&

3.區分：| 與 ||
相同點1：| 與 || 的運算結果相同
相同點2：當符號左邊是false時，二者都會執行符號右邊的運算
不同點3：當符號左邊是true時，|繼續執行符號右邊的運算，而||不再執行符號右邊的運算
開發中，推薦使用||

位運算子：<< >> >>> & | ^ ~

特別說明：

1. 位運算子操作的都是整型的資料
2. << ：在一定范圍內，每向左移1位，相當于 * 2
   >>: 在一定范圍內，每向右移1位，相當于/2

三元運算子：(條件運算式)? 運算式1 : 運算式2
特別說明

1. 說明
   ① 條件運算式的結果為boolean型別
   ② 根據條件運算式真或假，決定執行運算式1，還是運算式2.
   如果運算式為true，則執行運算式1，
   如果運算式為false，則執行運算式2，
   ③ 運算式1 和運算式2要求是一致的，
   ④ 三元運算子可以嵌套使用

2. 凡是可以使用三元運算子的地方，都可以改寫為if-else
   反之，不成立，

3. 如果程式既可以使用三元運算子，又可以使用if-else結構，那么優先選擇三元運算子，原因：簡潔、執行效率高，

4.流程控制

分支結構：
1.if-else條件判斷結構

結構一：
if (條件運算式) {
執行運算式
}

結構二：二選一
if (條件運算式) {
執行運算式1
}else{
執行運算式2
}

結構三：n選一
if (條件運算式) {
執行運算式1
}else if (條件運算式) {
執行運算式2
}else if (條件運算式) {
執行運算式3
}
…
else{
執行運算式n
}

2.switch-case選擇結構

switch (運算式) {
case 常量1:
執行陳述句1;
break;
case 常量2:
執行陳述句2;
break;
…
default:
執行陳述句n;
break;
}

回圈結構：

1.回圈結構的四要素

① 初始化條件
② 回圈條件 —>是boolean型別
③ 回圈體
④ 迭代條件
說明：通常情況下，回圈結束都是因為②中回圈條件回傳false了，

2.三種回圈結構：

2.1 for回圈結構

for(①;②;④){
③
}
執行程序：① - ② - ③ - ④ - ② - ③ - ④ - … - ②

2.2 while回圈結構

①
while(②){
③;
④;
}
執行程序：① - ② - ③ - ④ - ② - ③ - ④ - … - ②
說明：
寫while回圈千萬小心不要丟了迭代條件，一旦丟了，就可能導致死回圈！

for和while回圈總結：

1. 開發中，基本上我們都會從for、while中進行選擇，實作回圈結構，
2. for回圈和while回圈是可以相互轉換的！
   區別：for回圈和while回圈的初始化條件部分的作用范圍不同
3. 我們寫程式，要避免出現死回圈，

2.3 do-while回圈結構

①
do{
③;
④;
}while(②);
執行程序：① - ③ - ④ - ② - ③ - ④ - … - ②

說明：
1.do-while回圈至少會執行一次回圈體！
2.開發中，使用for和while更多一些，較少使用do-while

二、陣列

1.陣列概述

1.陣列理解： 陣列(Array)，是多個相同型別資料一定順序排列的集合，并使用一個名字命名，并通過編號的方式對這些資料進行統一管理，

2.陣列相關的概念：

陣列名
元素
角標、下標、索引
陣列的長度：元素的個數

3.陣列的特點：

1. 陣列是序排列的
2. 陣列屬于參考資料型別的變數，陣列的元素，既可以是基本資料型別，也可以是參考資料型別
3. 創建陣列物件會在記憶體中開辟一整塊連續的空間
4. 陣列的長度一旦確定，就不能修改，

4. 陣列的分類：
① 照維數：一維陣列、二維陣列、，，，
② 照陣列元素的型別：基本資料型別元素的陣列、參考資料型別元素的陣列

2.一維陣列

1.一維陣列的宣告與初始化

	int[] ids;//宣告
	//1.1 靜態初始化:陣列的初始化和陣列元素的賦值操作同時進行
	ids = new int[]{1001,1002,1003,1004};
	//1.2動態初始化:陣列的初始化和陣列元素的賦值操作分開進行
	String[] names = new String[5];

    int[] arr4 = {1,2,3,4,5};//型別推斷

錯誤的方式：
// int[] arr1 = new int[];
// int[5] arr2 = new int[5];
// int[] arr3 = new int[3]{1,2,3};

2.一維陣列元素的參考：通過角標的方式呼叫，
陣列的角標（或索引從0開始的，到陣列的長度-1結束）

3.陣列的屬性：length
System.out.println(names.length);//5
System.out.println(ids.length);

說明：
陣列一旦初始化，其長度就是確定的，arr.length
陣列長度一旦確定，就不可修改，

4.一維陣列的遍歷
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}

5.一維陣列元素的默認初始化值
> 陣列元素是整型：0
> 陣列元素是浮點型：0.0
> 陣列元素是char型：0或’\u0000’，而非’0’
> 陣列元素是boolean型：false
> 陣列元素是參考資料型別：null

3.二維陣列

1.如何理解二維陣列？
陣列屬于參考資料型別
陣列的元素也可以是參考資料型別
一個一維陣列A的元素如果還是一個一維陣列型別的，則，此陣列A稱為二維陣列，

2.二維陣列的宣告與初始化

int[] arr = new int[]{1,2,3};//一維陣列
	//靜態初始化
	int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
	//動態初始化1
	String[][] arr2 = new String[3][2];
	//動態初始化2
	String[][] arr3 = new String[3][];
//也是正確的寫法：
	int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
	int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//型別推斷

錯誤的方式：
// String[][] arr4 = new String[][4];
// String[4][3] arr5 = new String[][];
// int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

3.如何呼叫二維陣列元素:
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null

	arr3[1] = new String[4];
	System.out.println(arr3[1][0]);
System.out.println(arr3[0]);//

4.遍歷二維陣列元素

for(int i = 0; i < arr.length;i++)
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + " ")
}

4.陣列常見演算法

1.陣列的創建與元素賦值：
楊輝三角（二維陣列）、回形數（二維陣列）、6個數，1-30之間隨機生成且不重復，

2.針對于數值型的陣列：
最大值、最小值、總和、平均數等

3.陣列的賦值與復制
int[] array1,array2;
array1 = new int[]{1,2,3,4};
3.1 賦值：

array2 = array1;
如何理解：將array1保存的陣列的地址值賦給了array2，使得array1和array2共同指向堆空間中的同一個陣列物體，

3.2 復制：

array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
如何理解：我們通過new的方式，給array2在堆空間中新開辟了陣列的空間，將array1陣列中的元素值一個一個的賦值到array2陣列中，

5.Arrays工具類使用

1.理解：
① 定義在java.util包下，
② Arrays:提供了很多操作陣列的方法，

2.使用：

//1.boolean equals(int[] a,int[] b):判斷兩個陣列是否相等，
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):輸出陣列資訊，
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):將指定值填充到陣列之中，
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):對陣列進行排序，
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}

三、面向物件

java類及其類成員

1.類的設計中，兩個重要結構之一：屬性

對比：屬性 vs 區域變數

1.相同點：
1.1 定義變數的格式：資料型別 變數名 = 變數值
1.2 先宣告，后使用
1.3 變數都其對應的作用域

2.不同點：

2.1 在類中宣告的位置的不同
屬性：直接定義在類的一對{}內
區域變數：宣告在方法內、方法形參、代碼塊內、構造器形參、構造器內部的變數

2.2 關于權限修飾符的不同
屬性：可以在宣告屬性時，指明其權限，使用權限修飾符，
常用的權限修飾符：private、public、預設、protected —>封裝性
目前，大家宣告屬性時，都使用預設就可以了，
區域變數：不可以使用權限修飾符，

2.3 默認初始化值的情況：
屬性：類的屬性，根據其型別，都默認初始化值，
整型（byte、short、int、long：0）
浮點型（float、double：0.0）
字符型（char：0 （或’\u0000’））
布爾型（boolean：false）

		參考資料型別（類、陣列、介面：null）

	區域變數：沒默認初始化值，
	意味著，我們在呼叫區域變數之前，一定要顯式賦值，
		特別地：形參在呼叫時，我們賦值即可，

2.4 在記憶體中加載的位置：
屬性：加載到堆空間中 （非static）
區域變數：加載到堆疊空間

2.類的設計中，兩個重要結構之二：方法
方法：描述類應該具的功能，

1.舉例：

• public void eat(){}
• public void sleep(int hour){}
• public String getName(){}
• public String getNation(String nation){}

2. 方法的宣告：權限修飾符 回傳值型別 方法名(形參串列){
方法體
}

3. 說明：
3.1 關于權限修飾符：默認方法的權限修飾符先都使用public
Java規定的4種權限修飾符：private、public、預設、protected -->封裝性再細說

3.2 回傳值型別： 回傳值 vs 沒回傳值

3.2.1 如果方法回傳值，則必須在方法宣告時，指定回傳值的型別，同時，方法中，需要使用 return關鍵字來回傳指型別的變數或常量：“return 資料”，如果方法沒回傳值，則方法宣告時，使用void來表示，通常，沒回傳值的方法中，就不需要使用return.但是，如果使用的話，只能“return;”表示結束此方法的意思，

構造器（或構造方法）：
構造器的作用：

• 1.創建物件
• 2.初始化物件的資訊

使用說明：
1.如果沒顯式的定義類的構造器的話，則系統默認提供一個空參的構造器
2.定義構造器的格式：權限修飾符 類名(形參串列){}
3.一個類中定義的多個構造器，彼此構成多載
4.一旦我們顯式的定義了類的構造器之后，系統就不再提供默認的空參構造器
5.一個類中，至少會有一個構造器，

三大特性(封裝、繼承、多型)

面向物件的特征一：封裝與隱藏

1.為什么要引入封裝性？
我們程式設計追求“高內聚，低耦合”，
高內聚 ：類的內部資料操作細節自己完成，不允許外部干涉；
低耦合 ：僅對外暴露少量的方法用于使用，

隱藏物件內部的復雜性，只對外公開簡單的介面，便于外界呼叫，從而提高系統的可擴展性、可維護性，通俗的說，把該隱藏的隱藏起來，該暴露的暴露出來，這就是封裝性的設計思想，

2.封裝性思想具體的代碼體現：
體現一：將類的屬性xxx私化(private),同時，提供公共的(public)方法來獲取(getXxx)和設定(setXxx)此屬性的值
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
體現二：不對外暴露的私有的方法
體現三：單例模式（將構造器私有化）
體現四：如果不希望類在包外被呼叫，可以將類設定為預設的，

3.Java規定的四種權限修飾符

3.1 權限從小到大順序為：private < 預設 < protected < public
3.2 具體的修飾范圍：
3.3 權限修飾符可用來修飾的結構說明：

4.種權限都可以用來修飾類的內部結構：屬性、方法、構造器、內部類
修飾類的話，只能使用：預設、public

面向物件特征二:繼承性

1.繼承性的格式：
class A extends B{}

• A:子類、派生類、subclass
• B:父類、超類、基類、superclass

2.子類繼承父類以后有哪些不同？

2.1體現：一旦子類A繼承父類B以后，子類A中就獲取了父類B中宣告的所有的屬性和方法，
特別的，父類中宣告為private的屬性或方法，子類繼承父類以后，仍然認為獲取了父類中私的結構，只因為封裝性的影響，使得子類不能直接呼叫父類的結構而已，

2.2 子類繼承父類以后，還可以宣告自己特有的屬性或方法：實作功能的拓展，

• 子類和父類的關系，不同于子集和集合的關系，
• extends：延展、擴展

3.Java中繼承性的說明

3.1.一個類可以被多個子類繼承，

3.2.Java中類的單繼承性：一個類只能有一個父類
3.3.子父類是相對的概念，
3.4.子類直接繼承的父類，稱為：直接父類，間接繼承的父類稱為：間接父類
3.5.子類繼承父類以后，就獲取了直接父類以及所間接父類中宣告的屬性和方法

面向物件的特性三：多型性

1.多型性的理解：可以理解為一個事物的多種形態，

2.何為多型性：
物件的多型性：父類的參考指向子類的物件（或子類的物件賦給父類的參考）
舉例：
Person p = new Man();
Object obj = new Date();

3.多型性的使用：虛擬方法呼叫
有了物件的多型性以后，我們在編譯期，只能呼叫父類中宣告的方法，但在運行期，我們實際執行的是子類重寫父類的方法，
總結：編譯，看左邊；運行，看右邊，

4.多型性的使用前提：
① 類的繼承關系 ② 方法的重寫

6.多型性使用的注意點：
物件的多型性，只適用于方法，不適用于屬性（編譯和運行都看左邊）

關鍵字

關鍵字：this
1.可以呼叫的結構：屬性、方法；構造器

2.this呼叫屬性、方法：
this理解為：當前物件 或 當前正在創建的物件

2.1 在類的方法中，我們可以使用"this.屬性"或"this.方法"的方式，呼叫當前物件屬性或方法，但是通常情況下，我們都擇省略"this."，特殊情況下，如果方法的形參和類的屬性同名時，我們必須顯式的使用"this.變數"的方式，表明此變數是屬性，而非形參，

2.2 在類的構造器中，我們可以使用"this.屬性"或"this.方法"的方式，呼叫當前正在創建的物件屬性或方法，但是，通常情況下，我們都擇省略"this."，特殊情況下，如果構造器的形參和類的屬性同名時，我們必須顯式的使用"this.變數"的方式，表明此變數是屬性，而非形參，

3.this呼叫構造器：

① 我們在類的構造器中，可以顯式的使用"this(形參串列)"方式，呼叫本類中指定的其他構造器
② 構造器中不能通過"this(形參串列)“方式呼叫自己
③ 如果一個類中有n個構造器，則最多有 n - 1構造器中使用了"this(形參串列)”
④ 規定："this(形參串列)“必須宣告在當前構造器的首行
⑤ 構造器內部，最多只能宣告一個"this(形參串列)”，用來呼叫其他的構造器

關鍵字:abstract
abstract: 抽象的
1.可以用來修飾：類、方法
2.具體的：
abstract修飾類：抽象類

  此類不能實體化
 抽象類中一定有構造器，便于子類實體化時呼叫（涉及：子類物件實體化的全程序）
  開發中，都會提供抽象類的子類，讓子類物件實體化，完成相關的操作 --->抽象的使用前提：繼承性

abstract修飾方法：抽象方法

抽象方法只方法的宣告，沒方法體
包含抽象方法的類，一定是一個抽象類，反之，抽象類中可以沒有抽象方法的，
   若子類重寫了父類中的所的抽象方法后，此子類方可實體化
   若子類沒重寫父類中的所的抽象方法，則此子類也是一個抽象類，需要使用abstract修飾

3.注意點：

1.abstract不能用來修飾：屬性、構造器等結構
2.abstract不能用來修飾私方法、靜態方法、final的方法、final的類