感謝尚矽谷宋紅康老師

第一次在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的類