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 ‘\0’ ==> 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類有意義嗎？
沒有必要的！！！無意義的！！！