Java基礎回顧_Java方法詳解
- 何謂方法？
- 方法的多載
- 命令列傳參（不經常使用）
- 可變引數
- 遞回（重點）
- 陣列
  - 陣列的宣告創建
  - 陣列的記憶體分析
  - 陣列的四個基本特點
  - 陣列邊界
  - 陣列使用
  - 多維陣列
  - Arrays類
  - 八大排序
  - 稀疏陣列

Java基礎回顧_Java方法詳解

何謂方法？

Java方法是解決一類問題的步驟的有序組合
方法包含于類或物件中
方法在程式中被創建，在其它地方被參考

設計方法的原則：方法的本意是功能塊，就是實作某個功能的陳述句塊的集合，我們設計方法的時候，最好保持方法的原子性，就是一個方法只能完成一個功能，這樣利于我們后期的發展，

個人隨筆：

方法命名遵循 小駝峰原則
main方法盡量保持簡潔、干凈
方法其實就是C語言里的函式，方法遵循原子性，即一個方法只完成一件事
有些方法沒有return回傳值，于是方法體就不需要寫回傳值型別，這個時候就要用 void 替代 回傳值型別
有引數的方法一定要有return回傳值，沒有引數的方法即void方法就不需要return回傳值
引數型別這里得注意：引數型別分為形式引數 和實參（或稱為變數），

? 形式引數：形參就是創建方法的時候我個人定義的像 int a, int b 這樣的，沒有實際值，等著呼叫的時候再往里傳具體值的引數，相當于占位符，先把位置占著，用的時候再給它其他的值；

? 實參（或稱為變數）：方法在被呼叫的時候直接給引數賦值，像add( 1, 2);這種里面的 1和2 就是實參，

代碼格式：

修飾符 + 回傳值型別 + 自定義方法名 + （引數型別 + 引數名--->”引數可以定義一個或者多個“ ）{

? //執行的代碼陳述句，即方法體

? return + 回傳值；

}

例如：下面的add方法（加法）：

? public int add( int a, int b ){

? return a+b;

}

個人隨筆：

有時候用return 0；去終止方法，
方法的帶你用：用物件名去點方法名，例如：物件名.方法名（實參串列）

拓展了解：值傳遞和參考傳遞

Java都是值傳遞！只有值傳遞！

方法的多載

個人練習：

結合Scanner物件，完成手動輸入兩個整數列印最小值；以及直接注入三個整數然后得到三個整數中最小的那個，

這兩個方法的方法名都是min，但是它們的引數串列不一樣，一個是兩個變數（實參），一個是3個變數（實參）！！！！妙啊！！！

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("請依次輸入要比較的兩個整數：");
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int min = min(a, b);
        System.out.println("輸入的兩個整數中較小的那個整數是："+min);
        int min1 = min(6, 8, 3);
        System.out.println("三個整數中最小的整數是："+min1);
    }
    public static int min(int a,int b){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        return minNumber;
    }
    //多載的取最小值的方法，但是引數串列不一樣，多了一個引數
    public static int min(int a,int b,int c){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        if(minNumber<c){
            return minNumber;
        }else {
            minNumber=c;
        }
        return minNumber;
    }
}

方法多載的規則：

方法名稱必須一模一樣
引數串列必須不同，即引數的個數不同、或引數的型別不同、或引數的排列順序不同等
方法的回傳值型別可以相同，也可以不相同，但是僅僅只有回傳值型別不同也不行

個人隨筆：

當撰寫了多載的方法的時候，再去呼叫這些方法名相同的方法的時候，編譯器它自己會根據引數串列的差異去一個方法一個方法的找，知道找到對應的方法，如果找不到，它就會報錯！

命令列傳參（不經常使用）

有時候你希望運行一個程式的時候，再傳遞給它訊息，這個時候就要靠傳遞命令列引數給main()函式去實作，

可變引數

什么是可變引數？

有時候根據實際需求，可能需要用方法多載去撰寫幾十個甚至上百個方法名相同，引數鏈表不同的方法，這樣也太離譜了，這時候就誕生了可變引數 這種東西，它解決了上述問題！妙啊！！！！！！

用法：在引數串列中的引數宣告的引數型別后面加上一個省略號，例如：

利用可變引數，自定義任意的資料傳入方法，取得最大值！

public class Demo01 {
    public static void main(String[] args) {
        printMax(1,5,3,4,6,8,2,3,9,6,4);
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        if (numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];

        //排序！
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max Value is " + result);
    }
}

遞回（重點）

遞回就是：A方法呼叫A方法，即自己呼叫自己！遞回是一種思想！

遞回結構包括兩個部分：

遞回頭：就是有一串可以停止呼叫方法（函式）的代碼，讓程式不會無限回圈運行！
遞回體：

友情提示：能不用遞回就不用遞回，因為如果呼叫方法次數過多，會非常占用資源，影響性能！

個人練習：

寫一個計算器，要求實作加減乘除功能，并且能回圈接收新的資料，通過用戶互動實作（即Scanner物件）

用到了 while回圈 switch陳述句，實作了資料的回圈輸入并計算！！！！妙啊！！！！

import java.util.Scanner;

public class Calculator{
    public static void main(String[] args) {
        //創建物件用來呼叫物件里的方法
        Calculator calculator = new Calculator();
        //呼叫computer方法
        calculator.computer();
    }
    //第一步：加減乘除四個方法（因為要回圈計算，每次傳入一個數字，所以引數串列應該只有一個引數）
    //加法
    public static double add(double a){
        System.out.println("請輸入一個數：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a+b;
    }
    //減法
    public static double subtract(double a){
        System.out.println("請輸入一個數：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a-b;
    }
    //乘法
    public static double multiply(double a){
        System.out.println("請輸入一個數：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a*b;
    }
    //除法
    public static double divide(double a){
        System.out.println("請輸入一個數：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a/b;
    }

    //第二步：完成回圈輸入資料的功能（while（true）+switch）,必須創建一個方法完成這一步
    public void computer(){
        System.out.println("請輸入一個數：");
        Scanner scanner1 = new Scanner(System.in);
        double a = scanner1.nextDouble();

        while(true){
            Scanner scanner2 = new Scanner(System.in);
            System.out.println("你可以輸入的操作有：加(+)減(-)乘(*)除(/)清零(小寫的c)結束(小寫的end)--->");
            String str = scanner2.nextLine();
            switch (str){
                case "+":
                    a = add(a);
                    System.out.println("="+a);
                    break;
                case "-":
                    a = subtract(a);
                    System.out.println("="+a);
                    break;
                case "*":
                    a = multiply(a);
                    System.out.println("="+a);
                    break;
                case "/":
                    if (a == 0){
                        System.out.println("除法分子不能為零，請重新輸入：");
                        break;
                    }
                    a = divide(a);
                    System.out.println("="+a);
                    break;
                case "c":
                    computer();
                    break;
                case "end":
                    System.exit(-1);
                    break;
                default:
                    System.out.println("輸入的字符有誤！");
            }
        }
    }

}

陣列

什么是陣列 ?

陣列是相同型別 資料的有序組合，

陣列的宣告創建

首先必須宣告陣列變數，才能在程式中使用陣列，

一共兩種宣告陣列變數的格式如下：

int[] nums;//建議選擇這種宣告陣列變數的格式；
int nums2[];//不建議使用這種格式；這是c和c++里的格式，早些年為了程式員能快速掌握Java所以也有這種宣告陣列變數的格式

創建一個陣列

int[] nums;//建議選擇這種宣告陣列變數的格式；
int nums2[];//不建議使用這種格式；
nums = new int[10];//這里可以存放10個int型別的元素

//創建陣列，一步到位
double[] nums3 = new double[10];
System.out.println(nums3.length);//輸出nums3的陣列長度

陣列的記憶體分析

略...

陣列的三種初始化：

靜態初始化----------------------------->在宣告陣列的時候就直接給陣列賦值------>int[] a = {1,2,3,4,5};
動態初始化----------------------------->在宣告陣列之后，再給陣列賦值------>int[] a = new int[5]; a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
陣列的默認初始化-------------------->在宣告陣列之后，陣列里的元素默認為0------>int[] a = new int[5]；//a= {0,0,0,0,0}

陣列的四個基本特點

陣列被創建之后，長度就不能改變了；
陣列中所有的元素必須是同一資料型別；可以是任意資料型別，包括基本型別和參考型別；
陣列中的變數屬于參考型別，我們用的時候就去點它，陣列也可以看成是物件，其中的沒個元素都相當于是該物件的成員變數；
陣列本身就是物件，Java中的物件都在堆中，所以陣列物件本身是在堆中的，

陣列邊界

陣列下標從0開始到陣列長度減一，如果下標超了，就會報錯：ArrayIndexOutofBounds--------->陣列下標越界例外

陣列使用

For-Each 回圈
陣列當作引數傳入方法中
陣列當作回傳值回傳

多維陣列

int[][] a = {{1,2},{3,4},{8,9}};//這是一個二維陣列

個人理解：多維陣列就是不停的套娃！妙啊！！！！！！！！！！！

Arrays類

Arrays.toString(陣列名稱)；//可以列印出陣列所有陣列元素；
Arrays.sort(陣列名稱)；//可以對陣列排序：升序（從小到大）
Arrays.fill(陣列名稱,想要填充的值)；//可以對陣列進行填充：所有元素都會被想要填充的值給替換
Arrays.fill(陣列名稱,3,8,想要填充的值)；//只有陣列下標為3到8的元素被替換

八大排序

個人理解：

冒泡排序：比較陣列中兩個相鄰的元素，如果右邊的元素比左邊的小，則它們交換位置，達到左邊的元素永遠比右邊的元素小的效果；從右往左比較，這樣每個數都能被比較到，由于每次都將較小的移到了左邊，所以每比較完一輪，下一輪又從最右邊往最左邊比較的時候，就可以少比較一次（比如有5個元素，每次比較兩個元素的話，一輪就需要比較4次，第二輪就只需要比較3次，第三輪就只需要比較2次，第四輪就需要比較1次，然后就排好順序了）；--------------->時間復雜度為O(n的2次方)，

public class Demo01 {
    public static void main(String[] args) {
        int[] array2 ={1,4,8,3,5,9,2};
        System.out.println(Arrays.toString(fun1(array2  )));
    }
    //撰寫一個給陣列冒牌排序的方法，引數為陣列
    public static int[] fun1(int[] array1){
        //宣告一個用來給兩個相鄰元素交換位置的變數
        int t = 0;

        for (int i = 0; i < array1.length-1; i++) {
            for (int j = 0; j < array1.length-1-i; j++) {
                if (array1[j+1]<array1[j]){
                    t = array1[j];
                    array1[j] = array1[j+1];
                    array1[j+1] = t;
                }
            }
        }
        return array1;
    }
}

，，，

稀疏陣列

創建一個陣列，列印出它的稀疏陣列，并通過稀疏陣列列印出原陣列！！！！！！

public class Demo01 {
    public static void main(String[] args) {
        //二維陣列
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
        //將上面的二維陣列轉換為稀疏陣列保存起來
        //獲取有效值的個數
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        System.out.println("該二維陣列中有效值的個數為："+ count);

        //稀疏陣列
        //第一步：創建一個二維陣列，稱之為稀疏陣列
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏陣列的行數，列固定為3列
        //第二步，給這個稀疏陣列加入第一行應該展示的資料；
        array1[0][0] = array.length;//原陣列的行數
        array1[0][1] = array.length;//原陣列的列數
        array1[0][2] = count;//原陣列中有效值 的個數

        //第三步：給稀疏陣列賦值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步：列印輸出陣列
        System.out.println("原陣列array的稀疏陣列array1如下所示：");
        //遍歷輸出稀疏陣列array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
//        for (int i = 0; i < array1.length; i++) {
//            System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]);
//        }

        System.out.println("將稀疏陣列還原成原陣列:");
        //將稀疏陣列還原成原陣列
        //第一步：用稀疏陣列中第一行的值去創建一個二維陣列，用來顯示原陣列
        int array2[][] = new int[array1[0][0]][array1[0][1]];//確定陣列為幾行幾列
        //確認陣列的大小后，就要通過稀疏陣列中描述的原陣列的有效值傳入array2中
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        //第二步：列印array2陣列
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}

將上面的代碼寫為兩個方法：陣列轉稀疏陣列的方法，和，稀疏陣列轉原陣列的方法：

public class Demo01 {
    public static void main(String[] args) {
        //二維陣列
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("陣列array的稀疏陣列為：" );
        sparseArray(array);

        int[][] array1 = new int[3][3];
        array1[0][0] = 11;array1[0][1] = 11;array1[0][2] = 2;
        array1[1][0] = 1;array1[1][1] = 2;array1[1][2] = 1;
        array1[2][0] = 2;array1[2][1] = 3;array1[2][2] = 2;

        System.out.println("稀疏陣列array1的原陣列為：" );
        sparseArrayToArray(array1);

    }

    /**
     * 陣列 轉為 稀疏陣列
     * @param array
     */
    public static void sparseArray(int[][] array){
        //將上面的二維陣列轉換為稀疏陣列保存起來
        //獲取有效值的個數
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        //稀疏陣列
        //第一步：創建一個二維陣列，稱之為稀疏陣列
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏陣列的行數，列固定為3列
        //第二步，給這個稀疏陣列加入第一行應該展示的資料；
        array1[0][0] = array.length;//原陣列的行數
        array1[0][1] = array.length;//原陣列的列數
        array1[0][2] = count;//原陣列中有效值 的個數

        //第三步：給稀疏陣列賦值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步：列印輸出陣列

        //遍歷輸出稀疏陣列array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
    }

    /**
     * 稀疏陣列 轉為 陣列
     * @param sparseArray
     */
    public static void sparseArrayToArray(int[][] sparseArray){

        //將稀疏陣列還原成原陣列
        //第一步：用稀疏陣列中第一行的值去創建一個二維陣列，用來顯示原陣列
        int array2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];//確定陣列為幾行幾列
        //確認陣列的大小后，就要通過稀疏陣列中描述的原陣列的有效值傳入array2中
        for (int i = 1; i < sparseArray.length; i++) {
            array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //第二步：列印array2陣列
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/273112.html

標籤：Java

上一篇：關于動態規劃法

下一篇：實戰|如何優雅地自定義Prometheus監控指標