Java第二周學習
- 2020 年 3 月 18 日
- 筆記
Java第二周學習
1. 數組
1.1 定義數組格式
數據類型[] 數組名 = new 數據類型[容量];
int[] arr = new int[10];
賦值左側
數據類型: 告知編譯器，當前數組中能夠保存的數據類型到底是什麼？並且在確定數據類型之後，整個數組中保存的數據類型無法修改！！！ []:
- 告知編譯器這裡定義的是一個數組類型數據。
- 明確告知編譯器，數組名是一個【引用數據類型】
數組名:
- 操作數據非常重要的數據！！！
- 數組名是一個【引用數據類型】
小拓展: int(*) (void *, void *)
賦值號右側：
new: 申請【XX】記憶體空間，並且清空整個記憶體空間中所有二進位位，所有的二進位 位都是0 數據類型: 前後呼應，告知編譯器這裡支援存儲的數據類型到底是什麼？ [容量]: 容量==> Capacity 告知編譯器，當前數組中能夠存放的對應數據類型的數據，最大存儲多少 個！！ 【注意】 一旦確定容量，針對於當前數組，後期容量無法修改
1.2 數組的下標【重點】
規定 數組中的下標是從0開始，到數組的容量 – 1
例如: 數組容量為10 有效下標範圍: 0 ~ 9 超出有效下標範圍，都是無效下標，後期考慮數組處理異常問題，負數使用問題
操作會出現的問題: 1. 數組下標越界 ArrayIndexOutOfBoundsException
1.3 數組記憶體分析圖
【補充知識點 引用數據類型】 開發中引用數據類型 用於保存其他記憶體空間的首地址，保存地址之後，CPU可以通過對應的引用數據類型，得到對應的地址，從而訪問地址對應記憶體空間。 引用數據類型包括字元串，數組，對象。就這三個！
獲取數組容量的方式 數組名.length 屬性 當前數組的屬性length是要佔用一定的數組空間的，屬於數組中的內容，這就是為什麼數組中佔用的空間要比存儲數據計算空間略大一些。
1.4 數組地址轉移問題
class Demo3 { public static void main(String[] args) { int[] arr1 = new int[10]; int[] arr2 = new int[10]; arr1[5] = 100; arr2[5] = 500; System.out.println(arr1[5]); System.out.println(arr2[5]); arr1 = arr2; arr1[5] = 2000; System.out.println(arr1[5]); System.out.println(arr2[5]); } }
數組地址轉移示意圖
1.5 數組在方法中的使用
class Demo4 { public static void main(String[] args) { int[] array = new int[10]; // 調用賦值數組中元素的方法 // 調用參數是一個數組類型的方法，需要傳入的內容是數組名 assignIntArray(array); printIntArray(array); } /* 需求： 賦值一個int類型的數組 方法分析： public static 固定格式 不要問 返回值類型： void 無返回值 方法名: assignIntArray 見名知意，動賓結構，小駝峰命名法 形式參數列表: 這裡需要的是一個int類型的數組 (int[] arr) 方法聲明： public static void assignIntArray(int[] arr) */ /** * 賦值一個指定的int類型數組 * * @param arr 這裡需要的參數是一個int類型數組 */ public static void assignIntArray(int[] arr) { for (int i = 0; i < arr.length; i++) { arr[i] = i + 1; } } /* 需求 展示一個int類型數組中保存的數據 方法分析： public static： 不要問 返回值類型: void 方法名： printIntArray 形式參數列表： 這裡需要展示的是一個int類型數組 (int[] arr) 方法聲明: public static void printIntArray(int[] arr) */ /** * 展示一個int類型數組中保存的數據 * * @param arr 這裡需要的是一個int類型數組 */ public static void printIntArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println("array[" + i + "]=" + arr[i]); } } }
1.6 數組演算法
1.6.1 完成一個數組逆序過程
/* 靜態數組 int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}; 逆序完成 {10, 8, 6, 4, 2, 9, 7, 5, 3, 1}; 方法的分析 public static 不要問 返回值類型: void 不需要返回值 方法名: 逆序 reverse 形式參數列表: int[] arr 方法聲明: public static void reverse(int[] arr) */ /** * 完成對於int類型數組的逆序過程 * * @param arr int類型數組 */ public static void reverse(int[] arr) { int temp = 0; for (int i = 0; i < arr.length / 2; i++) { /* arr[0] = arr[9] arr[1] = arr[8] arr[2] = arr[7] arr[3] = arr[6] arr[4] = arr[5] */ temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } }
1.6.2 找出數組中最大值所在下標位置
class ArrayMethod2 { public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 19, 2, 4, 19, 8, 10}; int index = maxIndexOf(arr); System.out.println("index:" + index); } /* 需求 從int類型數組中找出對應的最大值下標位置 方法分析: public static 不要問 返回值類型： 數組的下標數據類型是int類型 int 方法名: maxIndexOf 形式參數列表： (int[] arr) 方法聲明： public static int maxIndexOf(int[] arr) */ /** * 返回指定int類型數組中最大值的下標位置 * * @param arr int類型數組 * @return 返回值是最大值所在的下標位置 */ public static int maxIndexOf(int[] arr) { // 假定下標為0的元素是數組中最大值。 int maxIndex = 0; // 因為循環過程中，沒有必要假定的下標為0的元素和自己比較 // 循環變數從1開始 for (int i = 1; i < arr.length; i++) { /* 如果發現maxIndex保存的下標對應元素，是小於i的 保存對應的i值 */ if (arr[maxIndex] < arr[i]) { maxIndex = i; } } return maxIndex; } }
1.6.3 找出數組中指定元素所在的第一次出現下標位置
class ArrayMethod3 { public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9}; int index = indexOf(arr, 1); if (index >= 0) { System.out.println("index : " + index); } else { System.out.println("Not Found!"); } } /* 需求: 找出數組中指定元素出現的第一次下標位置 1. 第一次出現的問題 2. 多個元素問題 3. 有可能不存在指定元素。 方法分析: public static 不要問 返回值類型: int 因為需要返回下標 考慮在int範圍以內，使用一個明確和正確數據有對立 關係的數據作為【錯誤標記】 找到對應數據 0 ~ array.length -1 -1 是一個明確的非法下標 方法名： indexOf 找出對應元素所在下標位置 形式參數列表: 首先是一個int類型數組 查詢的數據也是int類型 (int[] arr, int find) 方法聲明： public static int indexOf(int[] arr, int find) */ /** * 找出指定數組中，指定元素的下標位置，通過返回值返回 * * @param arr 指定的int類型源數據數組 * @param find 指定需要查詢的數據 * @return 返回值大於等於0，表示找到對應的數據，否則返回-1 */ public static int indexOf(int[] arr, int find) { // 首先假設對應查詢的數據是不存在的！！！ int index = -1; // 利用循環，從下標為0的元素開始到最大下標，比對是否存在find for (int i = 0; i < arr.length; i++) { // 發現指定find元素和下標為i的元素一致 if (find == arr[i]) { // 使用index保留對應的下標i index = i; // 終止循環！！！ break; } } return index; } }
1.6.4 獲取數組中指定下標的元素
class ArrayMethod4 { public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}; System.out.println(get(arr, 20)); } /* 需求 找出指定下標的元素 方法分析： public static 不要問 返回值類型： 數組為int類型，這裡返回值也是int類型 方法名: get 形式參數列表 指定的數組 int[] arr 指定的下標 int index 0 ~ arr.length - 1 方法聲明： public static int get(int[] arr, int index) */ /** * 找出數組中指定下標的元素 * * @param arr 指定的int類型數組 * @param int 指定查詢的下標位置 * @return 返回對應下標位置的元素 */ public static int get(int[] arr, int index) { // 用戶指定的index不能超出有效下標範圍 if (index < 0 || index > arr.length - 1) { /* 返回任何的數據類型都不合適，可以考慮終止方法， 並且告知用戶錯誤是什麼 後期課程中可以使用到異常處理 【用戶輸入參數合法性判斷】 */ System.out.println("Input Parameter is Invalid!"); // 當前方法退出！！！ System.exit(0); } return arr[index]; } }
1.6.5 找出數組中最小值的下標位置
public class Demo1 { public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9, 0, 4, 6, 8, 10}; // Ctrl + 1 Assign statement to new local variable int min = minIndexOf(arr); System.out.println("min index : " + min); } /* * 1.1 找出數組中最小值的下標位置 * * 方法分析： * public static 不要問 * 返回值類型: * 這裡需要返回數據是數組的下標 * int類型 * 方法名： * minIndexOf * 形式參數列表： * 這裡需要一個int類型數組 * (int[] arr) * 方法聲明: * public static int minIndexOf(int[] arr) */ /** * 當前方法是找出指定int類型數組中最小值所在的下標位置 * * @param arr int類型數組 * @return 最小值所在的下標位置 */ public static int minIndexOf(int[] arr) { // 假設最小值下標位置是下標為0的元素 int min = 0; for (int i = 1; i < arr.length; i++) { if (arr[min] > arr[i]) { min = i; } } return min; } }
1.6.6 找出數組中指定元素的最後一次出現的下標位置
public class Demo2 { public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9}; int index = lastIndexOf(arr, 7); System.out.println("last Index Of : " + index); } /* * 1.2 找出數組中指定元素的最後一次出現的下標位置 * 方法分析： * public static 不要問 * 返回值類型： * int 返回值是一個下標 * 方法名： * indexOf 第一次出現的位置 * lastIndexOf 最後一次出現的位置 * 形式參數列表: * 1. 源數據數組，int類型 * 2. 查詢的指定元素 int類型 * (int[] arr, int find) * 方法聲明： * public static int lastIndexOf(int[] arr, int find) */ /** * 找出數組中指定元素最後一次出現的位置 * * @param arr 指定的int類型源數據數組 * @param find 指定需要查詢的數據 * @return 返回值大於等於0表示找到數據，否則返回-1 */ public static int lastIndexOf(int[] arr, int find) { // 假設我們找不到對應的數據 int index = -1; for (int i = arr.length - 1; i >= 0; i--) { // 找到對應元素，保存index，終止循環 if (find == arr[i]) { index = i; break; } } return index; } }
1.6.7 找出指定元素在指定數組中所有下標位置 【難點】
/* 要求： a. 不允許在方法內列印展示 b. 考慮多個數據情況 c. 需要在方法外獲取到下標數據資訊 d. 不允許使用數組作為返回值 【重點】 1. 尾插法思想，計數器同時也是下一次存放數據的位置 2. 數組作為方法參數之後，是可以近似數據傳導 */ /** * 【重點】 * * @author Anonymous */ public class Demo3 { public static void main(String[] args) { int[] arr = {5, 3, 5, 7, 5, 1, 3, 5, 7, 9}; int[] indexArr = new int[arr.length]; int count = allIndexOf(arr, indexArr, 5); // count是查詢到的指定元素個數，同時可以利用與循環中，找到對應的元素 for (int i = 0; i < count; i++) { System.out.println(indexArr[i]); } } /* * 1.3. 找出指定元素在指定數組中所有下標位置 【難點】 * 要求： * a. 不允許在方法內列印展示 * b. 考慮多個數據情況 * c. 需要在方法外獲取到下標數據資訊 * d. 不允許使用數組作為返回值 * 方法分析: * public static 不要問 * 返回值類型: * int 返回找到的指定元素個數 * void 不行！！！少用黑盒方法！！！ * boolean true false 局限性比較大 * 方法名: * allIndexOf tips:感謝雄飛同學的友情提示 * 找出所有指定元素的下標位置 * 形式參數列表: * 1. 查詢數據的源數據數組 int[] arr * 2. 指定查詢的元素 int find * 3. 和源數據數組容量一致的int類型數組，保存對應的下標位置 * (int[] arr, int[] indexArr, int find) * 問題： * 1. 查詢數據可能是多個！！！ * 2. 數組不能作為返回值！！！ * 3. 不允許列印！！！ * 4. 外部獲取！！！ * 思考: * 1. 保存查詢數據的下標位置一定會使用到數組 * 2. 保存下標的數組數據類型是int類型 * 解決方案: * 通過方法為參數形式傳入一個數組，int類型，保存找到的下標位置 * 思考: * 保存下標的數組容量如果考慮 * 解決方案: * 哪怕源數據數組中所有數據都是指定的元素，最大容量也就是 * 和源數據數組的容量一致【判斷的地方！！！】 * * 問題: * 有沒有可能性下標為0的元素就是目標元素??? * 0是有效下標範圍 * * new創建一個新的數組，int類型數組中，所有的元素初始值都是0 * 任何判斷0是有效下標還是無效數據??? * 需求: * 這裡需要一個數據，告知我找到數據到底有多少個 * 返回值: * 找到的指定元素的個數，如果沒有找到，返回0 * * 方法聲明: * public static int allIndexOf(int[] arr, int[] indexArr, int find) * */ /** * 找到指定源數據數組中所有指定元素所在的下標位置，保存到indexArr中，並且返回值 * 是找到的元素個數 * * @param arr 源數據數組，int類型 * @param indexArr 找到的下標位置存儲數組，要求該數組的容量不得小於源數據容量 * @param find 需要查詢的指定數據 * @return 返回值大於0，找到的數據個數，沒有找到返回0 */ public static int allIndexOf(int[] arr, int[] indexArr, int find) { // 參數合法性判斷 // 如果存儲下標的數組長度小於原數組長度，有可能存儲不完數據， // 這裡就要提醒用戶給的數組長度不對 if (arr.length > indexArr.length) { System.out.println("Input Parameter is Invalid!"); // 參數不合法，沒有找到數據 return 0; } /* * 定義一個變數， * 1. 計數器，記錄找到的元素個數 * 2. 尾插法當中下一次存放元素的位置 */ int count = 0; // 利用for循環遍歷整個源數據arr數組 for (int i = 0; i < arr.length; i++) { // 找到了對應的元素，需要保存下標i if (find == arr[i]) { // 保存到indexArr數組中 // 需要使用尾插法！！！保存下一次存放數據的位置 indexArr[count] = i; // 計數器 += 1 count += 1; } } return count; } }
1.6.8 在指定位置插入指定元素【難點】
/* 存在一個數組，數組中的元素為 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0}; 要求 1. 0是無效元素，僅佔位使用 2. 當前數組中【有效元素】個數為9 需求 在該數組中的指定下標位置放入指定元素 【重點】 1. 空數據，無效數據思想 2. 數據的移動過程，粗加工，細打磨過程 3. 時間消耗問題 */
public class Demo4 { public static void main(String[] args) { int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0}; add(array, 9, 20); System.out.println(Arrays.toString(array)); } /* 1.4 在指定位置插入指定元素【難點】 存在一個數組，數組中的元素為 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0}; 要求 1. 0是無效元素，僅佔位使用 ==> null 2. 當前數組中【有效元素】個數為9 需求 在該數組中的指定下標位置放入指定元素 推演過程: 在數組下標為5的位置插入元素，從下標5開始 之後的元素整體向右移動 arr[9] = arr[8]; arr[8] = arr[7]; arr[7] = arr[6]; arr[6] = arr[5]; arr[5] = 20; 指定下標為5的位置添加元素，數組中的元素整體 向後移動的4次 方法分析： public static 不要問 返回值類型: void 可用，但是不建議 boolean 可以 true false 選擇boolean類型 int 可用 返回值的含義約束較為麻煩 方法名: add 添加操作 形式參數列表： 1. 需要插入數據的數組 2. 指定插入數據的下標位置 3. 指定插入的數據 (int[] arr, int index, int insert); 方法聲明： public static boolean add(int[] arr, int index, int insert); */ /** * 在指定的數組中，指定位置插入指定元素 * * @param arr 指定的int類型數組 * @param index 指定的下標位置，必須在合理的區間範圍以內 * @param insert 指定插入的元素，int類型 * @return 添加成功返回true，否則返回false */ public static boolean add(int[] arr, int index, int insert) { // 參數合法性判斷 if (index < 0 || index > arr.length - 1) { System.out.println("Input Parameter is Invalid!"); // 方法運行失敗！！！ return false; } /* arr[9] = arr[8]; arr[8] = arr[7]; arr[7] = arr[6]; arr[6] = arr[5]; arr[i] = arr[i - 1]; arr[i + 1] = arr[i]; arr[5] = 20; */ for (int i = arr.length - 1; i > index; i--) { arr[i] = arr[i - 1]; } arr[index] = insert; return true; } }
1.6.9 刪除數組中的指定下標的元素【難點】
/* 存在一個數組，數組中的元素為 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; 要求: 1. 0是無效元素，僅佔位使用 需求: 在當前數組中刪除指定下標的元素 例如: 指定下標5 結果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 0佔位！！！ */
package com.qfedu.a_array; import java.util.Arrays; public class Demo5 { public static void main(String[] args) { int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; remove(array, 9); System.out.println(Arrays.toString(array)); } /* 1.5 刪除數組中的指定下標的元素【難點】 存在一個數組，數組中的元素為 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; 要求: 1. 0是無效元素，僅佔位使用 需求: 在當前數組中刪除指定下標的元素 例如: 指定下標5 結果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 0佔位！！！ 推理過程: 從刪除位置開始，之後的元素整體向前移動， 並且需要在數組原本最後一個位置上存放元素0,0 是無效元素，佔位使用 arr[3] = arr[4]; arr[4] = arr[5]; arr[5] = arr[6]; arr[6] = arr[7]; arr[7] = arr[8]; arr[8] = arr[9]; arr[i] = arr[i + 1]; arr[i - 1] = arr[i]; arr[9] = 0; 方法分析： public static 不要問 返回值類型: boolean 方法名: remove 形式參數列表: 1. 刪除數據的數組 2. 指定刪除數據的下標位置 方法聲明: public static boolean remove(int[] arr, int index) */ /** * 刪除數組中指定下標元素的內容 * * @param arr 源數據數組，int類類型 * @param index 指定刪除的下標位置 * @return 刪除操作成功返回true，失敗返回false */ public static boolean remove(int[] arr, int index) { // 參數合法性判斷 // index < 0 || index >= arr.length if (index < 0 || index > arr.length - 1) { System.out.println("Input Parameter is Invalid"); return false; } /* arr[3] = arr[4]; arr[4] = arr[5]; arr[5] = arr[6]; arr[6] = arr[7]; arr[7] = arr[8]; arr[8] = arr[9]; arr[i] = arr[i + 1]; 從刪除位置開始，到數組的最後一個有效元素位置結束 */ for (int i = index; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } // 最後一位數據賦值為0，佔位，同時告知用戶這是一個無效數據 arr[arr.length - 1] = 0; return true; } }
1.6.10 找出數組中最大值元素，放到下標為0的位置
// 找出數組中最大的元素，放到下標為0的位置，下標為0的元素放到最大值元素位置 int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 }; System.out.println(Arrays.toString(arr)); // 假設最大值的下標位置為0 int index = 0; // 這裡一定可以得到最大值所在的下標位置 for (int i = 1; i < arr.length; i++) { if (arr[index] < arr[i]) { index = i; } } // 交換數據 if (index != 0) { int temp = arr[0]; arr[0] = arr[index]; arr[index] = temp; } System.out.println(Arrays.toString(arr));
1.6.11 接上一題，找出數組中剩餘元素的最大值，放到下標為1的位置
int index1 = 1; for (int i = 2; i < arr.length; i++) { if (arr[index1] < arr[i]) { index1 = i; } } if (index1 != 1) { int temp = arr[1]; arr[1] = arr[index1]; arr[index1] = temp; } System.out.println(Arrays.toString(arr));
1.6.12 再接上一題，找出數組中剩餘元素的最大值，放到下標為2的位置
int index2 = 2; for (int i = 3; i < arr.length; i++) { if (arr[index2] < arr[i]) { index2 = i; } } if (index2 != 2) { int temp = arr[2]; arr[2] = arr[index2]; arr[index2] = temp; } System.out.println(Arrays.toString(arr));
1.6.13 選擇排序演算法
public class Demo7 { public static void main(String[] args) { int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 }; System.out.println(Arrays.toString(arr)); selectSort(arr); System.out.println(Arrays.toString(arr)); } /* * 選擇排序演算法 * 方法分析： * public static 不要問 * 返回值類型: * void * 方法名: * selectSort * 形式參數列表: * 需要處理一個int類型數據 * (int[] arr) * * 方法聲明: * public static void selectSort(int[] arr) */ /** * 選擇排序演算法 * * @param arr 需要進行排序的int類型數據 */ public static void selectSort(int[] arr) { // 外層循環控制核心演算法的循環次數 for (int i = 0; i < arr.length - 1; i++) { // 從index位置開始找尋極值 int index = i; for (int j = i + 1; j < arr.length; j++) { if (arr[index] > arr[j]) { index = j; } } if (index != i) { int temp = arr[i]; arr[i] = arr[index]; arr[index] = temp; } } } }
1.7 Arrays數組工具類使用
數組的工具類: 提供了數組操作的基本方法 sort(int[] arr); 經過XXX,XXX,XXX三個大牛優化的利用XXX技術完成的快速排序演算法
binarySearch(int[] arr, int find); 二分法查詢，要求數組是有序的。
toString(任何類型數組); 把數組內容作出一個String類型字元串返回值 {1, 3, 5, 7, 9} ==> [1, 3, 5, 7, 9]
2. Eclipse使用
2.1 Eclipse使用
- 解壓縮Eclipse.rar
- 發送快捷方式到桌面
- 選擇自定義Workspace
- Eclipse開發環境選擇
- 創建Java Project a. 菜單欄 –> New – > Java Project b. Package Explorer –> 滑鼠右鍵 –> New – > Java Project
- 怎麼修改工作目錄默認保存的位置
3. 面向對象
3.1 Java中定義類的格式
class ClassName { // 屬性描述 // 行為描述 }
要求: 1. ClassName要求符合大駝峰命名法，並且要做到見名知意！！！ 2. 屬性描述，是用於描述當前類擁有的一些特徵，這裡可以使用變數 該變數有一個特定的名字【成員變數】 Field 3. 行為描述，是用於描述當前類可以做到一些事情，這裡使用方法。 該方法有一個特定的名字【成員方法】Method
3.2 Java中定義類【成員變數】
/** * 這裡定義的是一個Person類 * * @author Anonymous */ class Person { // 屬性描述，這裡使用成員變數 Field // 使用String類型來描述Person類的姓名屬性 String name; // 使用int類型數據描述Person類的年齡屬性 int age; // 使用char類型數據描述Person類的性別屬性 char gender; }
3.3 Java中定義類【成員方法】
// 使用方法描述Perosn類的吃飯行為 public void eat(String food) { System.out.println("吃" + food); } // 使用方法描述Person類的睡覺行為 public void sleep() { System.out.println("說出來你可能不行，是床先動的手~~~"); } // 使用方法描述Person類的打豆豆行為 public void daDouDou() { System.out.println("吃飯，睡覺，打豆豆"); } /* 特徵: 1. 目前沒有使用static關鍵字 2. 方法和之前所學方式形式一致，同樣擁有三大元素 返回值，方法名和形式參數列表 */
3.4 類對象使用
3.4.1 Java中創建類對象的形式
/* new 對象!!! */ // 獲取一個掃描器的類對象！！！ Scanner sc = new Scanner(System.in); /* java.util.Scanner : 數據類型，Scanner類型。創建的【變數】是Scanner的類對象，同時也是一個引用 數據類型 sc : 類對象，變數 Scanner的類對象，sc是對象名 new : 申請記憶體的【堆區】空間，並且清理整個空間中的所有數據。 程式碼中，只有有new關鍵字，一定會使用到記憶體的堆區空間，並且是新的記憶體空間。 Scanner(System.in) : 1. 這裡是一個方法，因為有小括弧 2. 方法名字和類名一致 3. 該方法稱之為構造方法，Constructor 構造方法 總結: 類名 對象名 = new 構造方法(所需參數); */ // 這裡創建了一個Person類對象，對象名person Person person = new Person(); System.out.println(person); /* * com.qfedu.a_object.Person@15db9742 * com.qfedu.a_object 完整的包名 * Person 數據類型，這裡創建的對象是一個Person類對象 * @15db9742 當前類對象在記憶體空間的中首地址！！！十六進位展示方式 */ Person person1 = new Person(); System.out.println(person1); /* * com.qfedu.a_object.Person@6d06d69c * 發現第二個Person類對象 person1空間首地址6d06d69c 和第一個對象不一致 * 這裡就意味著兩個對象的空間首地址不一致，不是同一個對象！！！ */
3.4.2 Java中使用類對象調用成員變數
/* int[] arr = new int[10]; 獲取數組的容量: arr.length 獲取一個數組中【的】length屬性 格式: 對象名.屬性名/成員變數名; . ==> 的 可以操作取值或者賦值操作。 */ // 通過Person類對象 person調用類內的成員變數 // 【賦值】Person類對象 person中對應的成員變數 person.name = "騷磊"; person.age = 16; person.gender = '男'; // 【取值】展示Person類對象 person中保存的成員變數數據 System.out.println("Name:" + person.name); System.out.println("Age:" + person.age); System.out.println("Gender:" + person.gender);
3.4.3 Java中使用類對象調用成員方法
/* 得到了一個Scanner類對象sc Scanner sc = new Scanner(System.in); 使用過以下方法： sc.nextInt(); sc.nextFloat(); sc.nextLine().charAt(0); 格式: 類對象.方法名(必要的參數); . ==> 的 */
3.5 類對象記憶體分析圖
3.6 類對象記憶體轉移問題
4. 構造方法 Constructor
4.1 Java編譯器提供的默認的構造方法
Java編譯器如果發現當前class沒有顯式自定義構造方法，會默認提供一個無參數構造方法給予使用。 如果Java編譯器發現在程式碼中出現了任何一個構造方法，就不會再提供對應的無參數構造方法。
4.2 自定義使用構造方法
構造方法功能: 初始化當前類對象中保存的成員變數數據。 目前創建對象的方式; new 構造方法(有可能需要的參數);
new： 1. 根據構造方法提供的數據類型申請對應的堆區記憶體空間。 2. 擦除整個空間中所有的數據。 構造方法: 初始化在當前記憶體堆區空間的成員變數對應的數據
格式: public 類名(初始化形式參數列表) { 初始化賦值語句; }
要求: 1. 無論什麼時候一定要留有一個無參數構造方法備用 2. 根據所需情況完成構造方法參數選擇 3. 一個class可以有多個構造方法【方法的重載】
5. 方法的重載
總結: 1. 所有的方法名字都是一致的！！！ 2. 所有的方法參數都是不一樣的！！！ 3. 同一個類內！！！
這就是方法的重載！！！ 優點: 1. 簡化了開發壓力 2. 簡化了記憶壓力 3. 更快捷的調用方法，同時又滿足了不同的情況！！！
規範： 重載情況下，在同一個類內，不可以出現相同方法名和相同參數數據類型的方法！！！
基本原理: 方法名一致的情況下，通過形式參數列表數據類型的不同來選擇不同的方法執行。 反射 ==>Constructor Method
6. this關鍵字
6.1 this關鍵字特徵
class SingleDog { public SingleDog() { System.out.println("Constructor : " + this); } public void test() { System.out.println("Method Called : " + this); } } /* * this關鍵字特徵: * this關鍵字表示調用當前方法的類對象， * 或者是當前構造方法中初始化的類對象 */ public class Demo4 { public static void main(String[] args) { SingleDog singleDog = new SingleDog(); System.out.println("Instance : " + singleDog); singleDog.test(); } }
6.2 解決就近原則問題
/** * 使用String類型參數和int類型參數初始化類對象成員變數數據 * * @param name String類型數據 用於初始化name屬性 * @param age int類型數據 用於初始化age屬性 */ public Cat(String name, int age) { name = name; age = age; System.out.println("帶有兩個參數的構造方法"); } /* 我們期望使用比較直觀的參數名方式，告知調用者這裡需要的數據到底是什麼？ 但是會導致【就近原則】問題 在構造方法中所有的name，age都會被看作是一個局部變數，而不是成員變數 期望: 可以有一種參數方式告知編譯器這裡操作的是一個成員變數，而不是一個局部變數！！！ */ --------------------------修改方式---------------------------------- /** * 使用String類型參數和int類型參數初始化類對象成員變數數據 * * @param name String類型數據 用於初始化name屬性 * @param age int類型數據 用於初始化age屬性 */ public Cat(String name, int age) { /* * 使用this關鍵字明確告知編譯器這裡使用的是一個成員變數，而不是 * 局部變數，解決就近原則問題 */ this.name = name; this.age = age; }
成員變數和局部變數的對比
|
區別 |
成員變數 |
局部變數 |
|---|---|---|
|
作用 |
屬性描述，描述當前類擁有哪些屬性 |
在方法運行的過程中保存必要的數據 |
|
位置 |
成員變數定義在class大括弧以內，其他大括弧之外 |
在方法大括弧或者程式碼塊大括弧以內 |
|
初始值 |
成員變數在沒有被構造方法賦值的情況下，是對應數據類型的"零"值 |
未賦值不能參與除賦值之外的其他運算。 |
|
作用域 |
成員變數存儲於類對象中，在記憶體的堆區，哪裡持有當前類對象的空間首地址，作用域就在哪裡 |
有且只在當前大括弧以內 |
|
生存期 |
成員變數的生存期是隨著類對象的創建而開始，當對象被JVM的GC銷毀時，成員變數的生存期終止 |
從定義位置開始，到當前大括弧結束 |
7. 【補充知識點 "零"值】
new關鍵字申請記憶體空間，並且擦除的一乾二淨 對應每一個數據類型的"零"值 基本數據類型 byte short int 0 long 0L float 0.0F double 0.0 char 『 』 ==> nul boolean false 引用數據類型 全部為null Person person null String str null int[] arr null
null 是記憶體地址中非常特殊的東西！！！
8. 【補充知識點 JVM的GC機制 簡述】
Java中記憶體管理制度GC就類似於圖書管理員身份 1. 在單位時間內，檢查當前Java程式使用的記憶體中是否存在無主記憶體。 2. 標記無主記憶體，多次標記的情況下，會將無主記憶體釋放，歸還記憶體空間。 好處: 1. 讓程式設計師管理記憶體更加方便。 2. 記憶體管理是完全自動化 劣勢: 1. 記憶體回收效率不高。 2. 記憶體管理出現泄漏問題。
9. 二分法查找
特徵: 1. 要求查詢的數組必須是一個經過排序之後的數組 2. 多個指定數據的情況下，無法告知到底是第幾個數據出現 3. 沒有找到數據返回負數 演示: 1 3 5 7 9 11 13 15 17 19 例如: 查詢元素 13的下標位置 第一步: 中間下標元素是 下標為4 元素值=9 最小下標為0 最大下標為9 9 < 13 需要修改最小下標 ==> 中間下標 + 1 ==> 5 第二步: 中間下標元素是 下標為7 元素值=15 最小下標為5 最大下標為9 15 > 13 需要修改最大下標 ==> 中間下標 – 1 ==> 6 第三步: 中間下標元素是 下標為5 元素值=11 最小下標為5 最大下標為6 11 < 13 需要修改最小下標 ==> 中間下標 + 1 ==> 6 第四步: 得到結果
/** * 二分法查找演算法 * * @param sortedArray 這裡要求是一個int類型數組，並且是進過排序之後的升序數組 * @param find 需要查詢的元素 * @return 返回值大於等於0找到元素下標位置，沒有找返回-1 */ public static int halfSearch(int[] sortedArray, int find) { int minIndex = 0; int maxIndex = sortedArray.length - 1; int mid = (minIndex + maxIndex) / 2; while (minIndex <= maxIndex) { if (sortedArray[mid] > find) { maxIndex = mid - 1; } else if (sortedArray[mid] < find) { minIndex = mid + 1; } else { return mid; } mid = (minIndex + maxIndex) / 2; } return -1; }
10. 面向對象的三大特徵之封裝
10.1 不局限於面對對象的封裝
方法的封裝 工具類的封裝 框架的封裝
需要擁有封裝的思想！！！可以用於整合的知識點！！！
10.2 符合JavaBean規範的類封裝過程
程式碼規範非常重要 後期可以有效的提供我們的開發效率！！！
在Java中定義符合JavaBean規範的類有什麼要求 1. 所有的成員變數全部私有化 ==> private 2. 必須提供一個無參數構造方法 3. 要求使用private修飾的成員變數提供對應的操作方法 ==> Setter Getter
10.3 private關鍵字
private關鍵字是一個許可權修飾符 private修飾的成員變數，成員方法，【構造方法】都是私有化內容，有且只能在類內使用，類外沒有任何的操作許可權！！！
10.4 Setter和Getter方法
private修飾的成員變數類外是沒有任何操作許可權，這裡需要提供對應的操作方法，setter和getter方法
Setter方法格式: public void set成員變數名(對應成員變數的數據類型 成員變數的形式參數) { this.成員變數名 = 成員變數的形式參數; }
例如: public void setName(String name) { this.name = name; }
Getter方法格式: public 對應成員變數的數據類型 get成員變數名() { return 成員變數; }
例如: public String getName() { return name; }
如果成員變數是一個boolean類型，Getter方法有所不同 boolean married; 格式: public boolean isMarried() { return married; }
11. 多類合作
11.1 什麼是多類合作
在開發中，除了基本數據類型，大多數情況下，都是類對象操作數據，作為 1. 方法的參數 2. 類定義時成員變數數據類型
11.2 成員變數的數據類型為自定義類型
汽車 發動機 輪胎
class Car 這裡需要的數據類型是我們的自定義複合數據類型，自定義類！！！ Engine engine Tyre tyre
發動機也需要一個類 class Engine 型號 排量
輪胎也需要一個類 class Tyre 型號 尺寸
12. 匿名對象
匿名對象: new 構造方法(必要的參數);
匿名對象的用途: 1. 使用匿名對象直接調用類內的成員方法 2. 匿名對象直接作為方法的參數
注意: 使用匿名對象不要操作成員變數，有可能是有去無回
優勢： 1. 閱後即焚，匿名對象在使用之後 立即被JVM GC收回 2. 解決記憶體空間，提高效率，簡化程式碼書寫
Factory factory = new Factory(); // 通過修理店對象，調用修理電腦的方法 // 需要的參數是Computer類對象 factory.repair(computer); /* Factory類對象 1. 有且只使用了一次 2. 該對象中的設置操作是沒有什麼作用的 問題： 1. 程式碼操作感覺不方便 2. 浪費時間浪費資源，記憶體資源，JVM效率問題 */
13. 面向對象的三大特徵之繼承
13.1 Java中實現繼承的方式
繼承使用的關鍵字 extends
格式: class A extends B{ } A類是B類的一個子類 B類是A類的唯一父類 Java中的繼承是一個單繼承模式
基本要求: 1. 子類繼承父類之後，可以使用父類的非私有化成員變數和成員方法 【非私有化成員】 2. 子類不能繼承得到父類的私有化內容。
13.2 繼承的問題
13.2.1 父類的構造方法被調用
13.2.2 為什麼會自動執行父類的無參數構造方法
這裡有一個super關鍵字 1. 調用父類成員方法和成員變數的關鍵字。 [解決就近原則問題] 2. 用於顯式調用父類的構造方法。
super關鍵字調用父類的構造方法 super(實際參數); Java編譯器會根據實際參數的數據類型，參數順序，選擇對應的父類構造方法執行，初始化父類的成員空間，方法重載機制。
特徵： 1. 如果沒有顯式調用父類的構造方法，默認Java編譯器會調用無參父類構造方法使用 2. 根據數據類型選擇對應方法 3. super調用構造方法，必須在當前構造方法的第一行
13.2.3 繼承帶來的問題
子類可以通過繼承獲取到父類中非私有化方法，但是父類的方法，不一定滿足子類的情況。 這裡不可能通過重新定義類似的方法名，完成子類特定的符合要求的方法。
13.2.4 方法的重寫
解決的問題就是在開發中，父類的方法不適用於子類情況，子類可以重寫父類的方法，完成自定義的方法使用 重寫之後，在沒有增加新的方法名的情況下，重寫方法體內容，讓方法滿足子類，降低了開發壓力，提高了效率。
@Override 嚴格格式檢查 要求重寫方法的和父類中的方法，聲明完成一致，返回值類型，方法名和形式參數列表
13.2.5 重寫和繼承帶來的問題
子類繼承父類可以直接使用父類的方法，但是在這種情況下我們可以發現父類的方法是一定不能在子類中使用的，但是又沒有一個強制要求。
需求： 強制要求子類重寫父類的方法，從語法角度約束
13.2.6 abstract關鍵字
abstract修飾的方法 要求子類強制重寫！！！
讓Eclipse幫著我們寫程式碼
第一個錯誤: Abstract methods do not specify a body abstract修飾的方法是沒有方法體 快速修復提示: Remove method body 刪除方法體
第二個錯誤: The abstract method Q in type LOLHero can only be defined by an abstract class 在LOLHero中使用abstract修飾的方法Q，只能定義在abstract修飾的類內 快速修復提示: Make Type 『LOLHero』 abstract
第三個錯誤： The type Yasuo must implement the inherited abstract method LOLHero.Q() 子類亞索類必須實現繼承而來的abstract方法 LOLHero.Q() 快速修復提示: Add unimplemented methods 添加沒有實現的父類中abstract方法
abstract使用總結: 1. abstract修飾的方法沒有方法體 2. abstract修飾的方法必須定義在abstract修飾的類內或者interface介面內 3. 一個普通類【非abstract】修飾的類，繼承了一個abstract類，那麼必須實現在abstract類內的所有abstract，強制要求 4. 如果一個abstract A類繼承另一個abstract B類，A類可以選擇實現B類中abstract方法。 5. abstract修飾的類內允許普通方法 6. abstract修飾的類不能創建自己的類對象！！！ 【原因】 abstract修飾的類內有可能存在abstract修飾的方法，而abstract修飾的方 法是么有方法體的，如果說創建了abstract修飾類對應的對象，不能執行沒 有方法體的abstract方法 7. 一個類內沒有abstract修飾的方法，那麼這個類定義成abstract類有意義嗎？ 沒有必要的！！！無意義的！！！
