Java基礎語法（三）
目錄不積跬步，無以至千里；不積小流，無以成江海， ——荀子《勸學》
- Java基礎語法（三）
- 十六、方法
- 十七、命令列傳參（擴展）
- 十八、可變引數（擴展）（本質：陣列）
- 十九、遞回
- 二十、陣列
- （一）陣列的定義：
- （二）陣列的宣告創建
- （三）陣列的初始化
- （四）Java記憶體分析
- （五）陣列的四個基本特點
- （六）陣列的邊界
- （七）多維陣列
- （八）陣列的應用——Arrays類
- （九）稀疏陣列（擴展）
十六、方法
-
方法的概念：執行一個功能的執行陳述句的集合，類似于其它語言的函式，
-
方法包含于類或者物件中，
-
方法的定義：
修飾符 回傳值型別 方法名(引數型別 引數名){ ... 方法體 ... return 回傳值; }-
修飾符：可選的，定義了該方法的型別，
-
回傳值型別：用于限定方法回傳值的資料型別，
-
方法名：方法的實際名稱，
-
引數型別：用于限定呼叫方法時傳入引數的資料型別，引數是可選的，方法可以不包含任何引數，
引數又分為形式引數（形參）和實際引數（實參），
形參：在方法被呼叫時用于接受外界輸入的資料，
實參：呼叫方法時實際傳給方法的資料，
-
方法體：具體執行功能的代碼陳述句，
-
-
方法的多載（重要）（以免跟后面方法的重寫混淆
多載就是在一個類中，有相同的方法名稱，但形參不同的函式，
方法的多載規則：
- 方法的名稱必須相同，
- 引數串列必須不同（引數個數不同、或者引數型別不同、或者引數的排列順序不同等）
- 方法的回傳型別可以相同可以不同，
- 僅僅是回傳型別不同不足以稱為方法的多載，
? 方法多載的原理：
? 方法名稱相同時，編譯器會根據呼叫方法的引數個數、引數型別逐一匹配，一選擇對應的方法，如果匹配失敗，則編譯器報錯，
例子：
public class demo1 {
public static void main(String[] args) {
int sum1 = add(1,2);
int sum2 = add(1,2,3);
double sum3 = add(1,2);
System.out.println(sum1);
System.out.println(sum2);
System.out.println(sum3);
}
public static int add(int x, int y){
return x + y;
}
//add方法引數個數不同方法多載
public static int add(int x, int y, int z){
return x + y + z;
}
//add方法引數型別不同方法多載
public static double add(double x, double y){
return x + y;
}
}
輸出結果：
3
6
3.0
十七、命令列傳參（擴展）
- 有時候希望運行一個程式時再傳遞給它訊息，就要靠傳遞命令列引數給 main() 函式實作，
package javase.method;
public class demo1 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
}
在該 Java 檔案目錄下使用命令列視窗進行編譯：
可以看到可以編譯，得到demo1.class檔案，
接著在該路徑下運行：
發現會報找不到或無法加載主類，原因是我們這個是在包里的，要將路徑回退到包所在的上一個路徑才能運行 .class 檔案，找到主類，
回退到 src 路徑下要執行 包名+檔案名 的完整路徑才能正常運行，否則還是執行不了，
接著在執行命令里面傳遞引數，結果如下：
十八、可變引數（擴展）（本質：陣列）
- JDK1.5開始，Java支持傳遞同型別的可變引數給一個方法，
- 在方法宣告中，在指定引數型別后加一個省略號（...），
- 一個方法中只能指定一個可變引數，它必須是方法的最后一個引數，任何普通引數必須在它之前宣告，
public class demo2 {
public static void main(String[] args) {
max(1,2,3,4,5);
max(5.2,9.9,3.14);
}
public static void max(double... num){
if(num.length == 0){
System.out.println("沒有引數，");
return;
}
double result = num[0];
for(int i = 1; i < num.length;i++){
if(num[i] > result){
result = num[i];
}
}
System.out.println(result);
}
//public static void max(double... num,int b)報錯，可變引數只能是方法最后一個引數
}
輸出：
5.0
9.9
十九、遞回
-
遞回：A方法呼叫A方法，
-
遞回結構包括兩個部分：
- 遞回頭：什么時候不呼叫自身方法，如果沒有將陷入死回圈，
- 遞回體：什么時候需要呼叫自身方法，
-
優點：大大減少代碼量，用有限的陳述句來定義物件的無限集合，
-
缺點：容易陷入死回圈和造成堆疊溢位，（
java.lang.StackOverflowError），所以一般不推薦使用， -
例子：求比較小的數的階乘，
public class demo3 { public static void main(String[] args) { int result = f(6); System.out.println(result); } public static int f(int n){ if(n == 1){ return 1; }else{ return n * f(n-1); } } }輸出： 720
二十、陣列
（一）陣列的定義：
陣列是相同型別資料的有序集合，陣列中的每個資料稱為元素，每個陣列元素可以通過一個下標來訪問它們，
陣列可以存放任意型別的元素，但是同一個陣列里存放的元素型別必須相同，
（二）陣列的宣告創建
首先必須先宣告陣列變數，才能在程式中使用陣列，宣告陣列的語法：
dataType[] arr; //最好使用
或者
dataType arr[];
Java語言使用 new 運算子來創建陣列，語法：
dataType[] arr = new dataType[arraySize];
陣列的元素是通過索引訪問的，陣列索引從 0 開始，
獲取陣列的長度：arr.length
（三）陣列的初始化
-
動態初始化：在定義陣列時，只指定陣列的長度，由系統自動為元素賦初值的方法，后面可以自己修改元素值，
//動態初始化 int[] a = new a[3]; a[0] = 1; a[1] = 2 -
靜態初始化：在定義陣列的同時就為陣列的每個元素賦值，
/*靜態初始化陣列的兩種方法 1.型別[] 陣列名 = new 型別[]{元素值1，元素值2，...}; 2.型別[] 陣列名 = {元素值1，元素值2，...}; */ int[] b = new int[]{1,2,3}; int[] c = {1,2,3}; -
動態初始化陣列元素默認值：
- 整數型別：0
- 浮點數型別：0.0
- char：一個空字符，即 ’ \u0000 '（注意：不是空格）
- boolean：false
- 參考資料型別：null
（四）Java記憶體分析
（五）陣列的四個基本特點
-
其長度是確定的，陣列一旦被創建，它的大小就不可以改變，
-
一個陣列的元素必須是相同型別的，不允許出現混合型別，
-
陣列中的元素可以是任何資料型別，包括基本型別和參考型別，
-
陣列變數屬于參考型別，陣列也可以看成是物件，陣列中的每個元素相當于該物件的成員變數，Java中物件是在堆中的，因此陣列無論保存原始型別還是其他物件型別，陣列物件本身是在堆中，
（六）陣列的邊界
下標（索引）的合法區間 [ 0 , length - 1 ]，如果越界就會報錯！
ArrayIndexOutOfBoundsException：陣列下標越界例外！
（七）多維陣列
-
多維陣列可以看成陣列的陣列，比如二維陣列就像是一個特殊的一維陣列，其每一個元素都是一個一維陣列，
-
二維陣列的定義：
//1. 動態初始化1.arr是一個兩行三列的陣列，arr是一個兩行三列的陣列 int[][] arr = new int[2][3]; arr[0][1] = 0; ...... //2. 動態初始化2 int[][] arr = new int[2][]; //只宣告行數，不宣告列數 //3. 靜態初始化 int[][] arr = new int[][]{{1,2},{3,4,5,6},{7,8,9}}; int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}; //錯誤情況： String[][] arr = new String[][4]; //只宣告列數，不宣告行數 String[4][3] arr = new String[][]; int[][] arr = new int[4][4]{{1,2},{3,4,5,6},{7,8,9}}; -
二維陣列可以只宣告行數，不能只宣告列數的原因：
與陣列創建的記憶體有關，
（八）陣列的應用——Arrays類
-
陣列的工具類：java.util.Arrays
-
Arrays類中的方法都是 static 修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而不用使用物件來呼叫（注意：是“不用”而不是“不能”），
-
常用功能：
- 給陣列賦值：通過 fill 方法，
- 對陣列排序：通過 sort 方法，
- 比較陣列：通過 equals 方法比較陣列中的元素值是否相等，
- 查找陣列元素：通過binarySearch方法能對排序好的陣列進行二分查找法操作，
- 列印陣列：通過 toString 方法，
-
例子
import java.util.Arrays; public class demo1 { public static void main(String[] args) { int[] a = {11,5,6,1,85,64,33}; System.out.println(Arrays.toString(a)); Arrays.sort(a); System.out.println(Arrays.toString(a)); Arrays.fill(a,0); System.out.println(Arrays.toString(a)); Arrays.fill(a,2,4,1); //陣列下標[2，4）區間的元素填充值 1 System.out.println(Arrays.toString(a)); } }
輸出結果：
[11, 5, 6, 1, 85, 64, 33]
[1, 5, 6, 11, 33, 64, 85]
[0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 0, 0]
（九）稀疏陣列（擴展）
-
當一個陣列中大部分元素為 0 ，或者大部分元素為同一值的陣列時，可以使用稀疏陣列來保存該陣列，
-
稀疏陣列的處理方式：
- 記錄陣列一共有幾行幾列，有多少不同的值，
- 把具有不同值元素的行列下標及值記錄在一個小規模的陣列中，從而縮小程式的規模，
-
例子：
左邊為原始陣列，后邊為稀疏陣列，
稀疏陣列的第一行記錄陣列一共有幾行幾列，有多少個不同的值，
接下來幾行就是記錄不同值元素的行下標、列下標及值，
public class demo2 {
public static void main(String[] args) {
//創建一個二維陣列
int[][] arr1 = new int[6][7];
//向二維陣列里放值
arr1[0][3] = 22;
arr1[0][6] = 15;
arr1[1][1] = 11;
arr1[1][5] = 17;
arr1[2][3] = -6;
arr1[3][5] = 39;
arr1[4][0] = 91;
arr1[5][2] = 28;
//列印二維陣列
System.out.println("列印二維陣列");
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
//二位陣列----->稀疏陣列
//遍歷二維陣列中有效值的個數,用sum來記錄
int sum = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
if (arr1[i][j] != 0){
//二維陣列中元素不為0即為有效值
sum++;
}
}
}
//創建稀疏陣列
//行數為sum+1，第一行用于保存二維陣列的行列及有效值個數，列數固定為3
int[][] sparseArr = new int[sum + 1][3];
//存入二維陣列的行列及有效值個數
sparseArr[0][0] = arr1.length;
sparseArr[0][1] = arr1[0].length;
sparseArr[0][2] = sum;
//再次遍歷二維陣列，將有效值存入稀疏陣列
//用于保存稀疏陣列的行數
int count = 1;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
if (arr1[i][j] != 0) {
//將值存入稀疏陣列
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = arr1[i][j];
count++;
}
}
}
//列印稀疏陣列
System.out.println("遍歷稀疏陣列");
for (int i = 0; i < sparseArr.length; i++) {
for (int j = 0; j < sparseArr[0].length; j++) {
System.out.print(sparseArr[i][j] + " ");
}
System.out.println();
}
//稀疏陣列------>二維陣列
//先得到二位陣列的行列數
int row = sparseArr[0][0];
int col = sparseArr[0][1];
int[][] arr2 = new int[row][col];
//遍歷稀疏陣列，同時給二維陣列賦值
for (int i = 1; i < sparseArr.length; i++) {
row = sparseArr[i][0];
col = sparseArr[i][1];
//該位置上對應的值
int val = sparseArr[i][2];
arr2[row][col] = val;
}
//列印二維陣列
System.out.println("遍歷還原后的二維陣列");
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[0].length; j++) {
System.out.print(arr2[i][j] + " ");
}
System.out.println();
}
}
}
輸出：
列印二維陣列
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
遍歷稀疏陣列
6 7 8
0 3 22
0 6 15
1 1 11
1 5 17
2 3 -6
3 5 39
4 0 91
5 2 28
遍歷還原后的二維陣列
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/438011.html
標籤：其他
上一篇：物件，Java集合總結