java day07 物件的建立分析及面向物件三大特性中的封裝與繼承

阿新 • • 發佈：2020-12-13

Java的方法詳解

什麼是方法？

Java方法是語句的集合，它們在一起執行一個功能。
- 方法是解決一類問題的步驟的有序組合
- 方法包含於類或物件中
- 方法在程式中被建立，在其他地方被引用
設計方法原則：方法的本意是功能塊，即實現某個功能的語句塊集合。因此在設計方法時，最好保持方法的原子性，就是一個方法完成1個功能，有利於後期的擴充套件。
方法的命名規則：駝峰式，如addSalary()

方法的定義及呼叫

Java的方法類似於C語言的函式，是一段用來完成特定功能的程式碼段，一般情況下，定義一個方法包含以下語法：
方法包含一個方法頭和一個方法體，以下是一個方法的所有部分：
- 修飾符
  
  ——可選的，告訴編譯器如何呼叫該方法，定義了方法的訪問型別
- 返回值型別——方法可能會有返回值。returnValueType是方法返回值的資料型別，有些方法執行所需的操作，但沒有返回值，在這種情況下，returnValueType是關鍵字void
- 方法名——方法的實際名稱，方法名和引數表共同構成方法簽名。
- 引數型別——引數像是一個佔位符。當方法被呼叫時，傳遞值給引數。這個值被稱為實參或變數。引數列表是指方法的引數型別、順序和引數個數。引數是可選的，方法可以不包含任何引數。
  - 形式引數——在方法被呼叫時用於接收外界輸入的資料
  - 實參——呼叫方法時實際傳給方法的引數；
- 方法體——包含具體的語句，定義該方法的功能

修飾符  返回值型別  方法名(引數型別 引數名){
    ...
    方法體
    ...    
    return 返回值;
}

package com.leoDolphin.method;

public class Demo02 {
    public static void main(String[] args) {
        int larger = max(10,20);
        System.out.println(larger);
    }
    //比大小
    public static int max(int num1,int num2) 
{
        int result;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//終止方法，後面的不會再執行
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
}

20
Process finished with exit code 0

呼叫方法：物件名.方法名（實參列表）
Java支援兩種呼叫方法的方式，根據方法是否返回值來選擇
當方法返回一個值得時候，方法通常被當作一個值，如：
```
int larger = max(30,40);
```
如果方法返回值是void，方法呼叫一定是一條語句
```
System.out.print("Hello,LeoDolphin!");
```

值傳遞（Java）和引用傳遞

值傳遞—— 實參傳遞給形參的值，實參和形參再記憶體上是兩個獨立的變數，對形參的修改不會影響實參的值，如下修改形參的值，不會改變實參的值。形參是實參建立的一個副本，副本改變不會影響原本

package com.leoDolphin.method;

public class ParamDemo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        change(a,b);
        System.out.println("列印呼叫方法後的變數："+a+","+b);
    }

    public static void change(int aa,int bb){
        aa=20;
        bb=30;
        System.out.println("列印方法中的變數："+aa+","+bb);
    }
}

列印方法中的變數：20,30
列印呼叫方法後的變數：10,20

引用傳遞—實參是傳遞給形參的是堆記憶體上引用的地址，形參和實參在記憶體上指向的是同一地址，對形參的改變會影響實參，如下實參傳遞給形參的是堆記憶體應用的地址，對形參的修改會影響實參

package com.leoDolphin.method;

public class ParamDemo02 {
    public static void main(String[] args) {
        int[] a = {1,2,3};
        int[] b = {4,5,6};
        //陣列序列號是從0開始的
        System.out.println("列印呼叫方法前的陣列："+a[0]+","+a[1]+","+a[2]+";"+b[0]+","+b[1]+","+b[2]);
        change(a,b);//傳入的陣列變數，其實是陣列的首位地址，即引用傳值
        System.out.println("列印呼叫方法後的陣列："+a[0]+","+a[1]+","+a[2]+";"+b[0]+","+b[1]+","+b[2]);
    }

    public static void change(int[] aa,int[] bb){
        aa[1]=22;//改變了陣列的第2個值
        bb[2]=66;//改變了陣列的第3個值
        System.out.println("列印方法中的陣列："+aa[0]+","+aa[1]+","+aa[2]+";"+bb[0]+","+bb[1]+","+bb[2]);
    }
}

列印呼叫方法前的陣列：1,2,3;4,5,6
列印方法中的陣列：1,22,3;4,5,66
列印呼叫方法後的陣列：1,22,3;4,5,66

方法的過載

過載就是在一個類中，有相同的函式名稱，但形參不同的函式
方法的過載規則：
- 方法名必須相同
- 引數列表必須不同（個數不同，或型別不同、闡述排列順序不同等）
- 方法的返回型別可以相同，也可以不相同
- 僅僅返回型別不同不足以成為方法的過載
實現理論：
- 方法名稱相同時，編譯器會根據呼叫方法的引數個數，引數型別等逐個去匹配，以選擇對應的方法，如果匹配失敗，則編譯器報錯。

package com.leoDolphin.method;

public class Demo02 {
    public static void main(String[] args) {
        int larger = max(10,20);
        double larger2 = max(10.4,20.5);
        System.out.println(larger);
        System.out.println(larger2);
    }
    //比大小double
    public static double max(double num1,double num2){
        double result;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//終止方法，後面的不會再執行
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
    //比大小int
    public static int max(int num1,int num2){
        int result;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//終止方法，後面的不會再執行
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
}

20
20.5

命令列傳參

有時候希望執行一個程式時候再傳遞給它訊息，這要靠傳遞命令列引數給main()函式實現。

package com.leoDolphin.method;

public class CommandLine {
    public static void main(String[] args) {
        for (int i = 0;i<args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

在這裡插入圖片描述

可變引數

可變引數也叫不定項引數
JDK5開始，Java支援傳遞同類型的可變引數給一個方法
在方法宣告中，在指定引數型別後加一個省略號（…）
一個方法中只能指定一個可變引數，它必須是方法的最後一個引數。任何普通的引數必須在它之前宣告。

package com.leoDolphin.method;

public class Demo04 {
    public static void main(String[] args) {
        printMax(34,4,5,6,7,40.5);
        printMax(new double[]{1,2,3,4,5});
    }
    //不知道呼叫方到底會傳多少個同類型的引數，因此用到可變引數，其實質是陣列，因此也是引用傳遞，一定要注意值在方法中儘可能不去改變
    public static void printMax(double... numbers){
        if (numbers.length==0){
            System.out.println("沒有值傳入！");
        }
        double result = numbers[0];
        //排序
        for (int i=1;i<numbers.length;i++){
            if (numbers[i]>result){
                result = numbers[i];
            }
        }
        System.out.println("最大值為："+result);
    }
}

最大值為：40.5
最大值為：5.0

遞迴

一般A方法呼叫B方法是比較常見的呼叫方式，而遞迴就是A方法呼叫A方法自己
利用遞迴可以用簡單的程式來解決一些複雜的問題。它通常把一個大型複雜的問題層層轉化為一個與原問題相似的規模較小的問題來求解，遞迴策略只需少量的程式就可描述出解題過程所需要的多次重複計算，大大減少了程式的程式碼量。
遞迴的能力在於用有限的語句來定義物件的無限集合
遞迴結構包括兩個部分：
- 遞迴頭：什麼時候不呼叫自身方法。如果沒有頭，將陷入死迴圈
- 遞迴體：什麼時候需要呼叫自身方法

package com.leoDolphin.method;

public class Demo05 {
    //階乘，計算一個數字的階乘
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        if(n==1){
            return 1;//遞迴頭
        }else{
            return n*f(n-1);//遞迴體
        }

    }
}