java中方法的使用

什么是方法

舉一個日常生活中的例子，比如我們在學校班長都會發(fā)送消息，比如它想讓班級里的每一個人到某某教學樓某某班級進行開會，他就會給每個人發(fā)信息，同學今天我們有重要會議要進行開班會請你到某某教學樓某某班級來，如果班長要給每一個人發(fā)送信息，一個班里有很多人這樣班長發(fā)信息就會很累，換個思路，班長要群發(fā)消息這樣是不就會很省心。這也就是與java中的方法類似，我們定義一個方法實現(xiàn)你需要的功能，在你想要調(diào)用并且實現(xiàn)這個功能你就可以任意調(diào)用。

在編程中如果重復實現(xiàn)某個功能就會

1.使程序變得繁瑣

2.開發(fā)效率低下，做了大量重復性的工作

3. 不利于維護，需要改動時，所有用到該段代碼的位置都需要修改

4. 不利于復用。

方法的意義：

1. 是能夠模塊化的組織代碼(當代碼規(guī)模比較復雜的時候).

2. 做到代碼被重復使用, 一份代碼可以在多個位置使用.

3. 讓代碼更好理解更簡單.

4. 直接調(diào)用現(xiàn)有方法開發(fā), 不必重復造輪子

方法的定義與使用

定義規(guī)范：

修飾符 返回值類型 方法名稱([參數(shù)類型 形參 ...]){
方法體代碼;
[return 返回值];
}

我們舉一個例子：判斷是否是閏年：

    public static boolean isLeapYear(int year) {
        if(year%4==0&&year%100!=0||year%400==0) {
            return true;
        }
        return false;
    }

實現(xiàn)兩個數(shù)的加法：

    public static int add(int x, int y) {
    //實現(xiàn)兩個數(shù)的加法
        return x + y;
    }

這樣的方法就可以在你需要這個功能的時候進行調(diào)用，不需要你在寫一遍，減少了代碼的冗余。

一些關(guān)于方法的注意事項：

1. 修飾符：現(xiàn)階段直接使用public static 固定搭配

2. 返回值類型：如果方法有返回值，返回值類型必須要與返回的實體類型一致，如果沒有返回值，必須寫成void

3. 方法名字：采用小駝峰命名

4. 參數(shù)列表：如果方法沒有參數(shù)，()中什么都不寫，如果有參數(shù)，需指定參數(shù)類型，多個參數(shù)之間使用逗號隔開

5. 方法體：方法內(nèi)部要執(zhí)行的語句

6. 在java當中，方法必須寫在類當中

7. 在java當中，方法不能嵌套定義

8. 在java當中，沒有方法聲明一說

方法如何進行調(diào)用及其方法調(diào)用過程

舉一個例子：還是上面那個例子判斷閏年？

 public static boolean isLeapYear(int year) {
        if(year%4==0&&year%100!=0||year%400==0) {
            return true;
        }
        return false;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("請您輸入year判斷是否是閏年？：>");
        int year =scan.nextInt();
        if(isLeapYear(year)) {
            //是閏年
            System.out.print(year+"是閏年");
        } else {
            System.out.print(year+"不是閏年");
        }
 }

我們來剖析一下這段代碼：

首先我們需要定義一個年份：

調(diào)用方法：

我們可以總結(jié)一下方法的調(diào)用過程大致是：

調(diào)用方法--->傳遞參數(shù)--->找到方法地址--->執(zhí)行被調(diào)方法的方法體--->被調(diào)方法結(jié)束返回--->回到主調(diào)方法繼續(xù)往下執(zhí)行

注意事項：

只有定義完方法之后才可以調(diào)用方法。并且只有調(diào)用方法時，方法才會執(zhí)行。

我們定義的方法可以多次重復調(diào)用。完成我們想要完成的需求。

舉個實例：計算1！+2！+3！+4！+5！；

這個代碼雖然簡單但是可以證明我們把一個功能都實現(xiàn)成一個方法，這樣我們調(diào)用起來，代碼邏輯就很清晰，所以建議我們實現(xiàn)一個功能的時候都要把它封裝成一個方法。

方法的形參和實參

Java中方法的形參就相當于sum函數(shù)中的自變量n，用來接收sum函數(shù)在調(diào)用時傳遞的值的。形參的名字可以隨意取，對方法都沒有任何影響，形參只是方法在定義時需要借助的一個變量，用來保存方法在調(diào)用時傳遞過來的值。

例如：實現(xiàn)一個方法交換兩個整型變量

傳值調(diào)用：

根據(jù)上面的答案，并不是我們想要的結(jié)果那是為什么呢？

我們來剖析一下：

有的人還會說那我把形參寫成 a和b他會交換a和b的值么？

答案并不會，形參的名字可以任意取與名字無關(guān)，如果寫成a和b那只能說明原來的兩人和你形參這兩個人是重名的，并不會本質(zhì)的改變。

那我們究竟怎么才能改變兩個數(shù)的值呢？ 

這就與c語言類似，在c語言中是傳兩個數(shù)的地址而在java中傳的是引用，引用存儲的是這兩個變量在內(nèi)存的地址，通過地址就可以改變。

由于java語言中沒有所謂的取地址，在Java中有引用類型，引用類型所引用的變量就是存儲在內(nèi)存當中的地址。通過地址就可以實質(zhì)的改變某個值。

在java中引用類型有許多比如，類，對象，數(shù)組，字符串等等。

我們接下來利用數(shù)組進行交換兩個數(shù)的值。

public static void Swap(int[] array) {
        int tmp = array[0];
        array[0] = array[1];
        array[1] = tmp;
    }
public static void main(String[] args) {
        int[] array =new int[]{10,20};
        Swap(array);
        System.out.println(Arrays.toString(array));
}

為啥兩個值交換呢？因為數(shù)組是引用類型，引用變量（這里是array）存放的是數(shù)組中的元素在內(nèi)存中的地址，通過地址就可以真正的改變這兩個值。

方法重載

百度百科：方法重載是指在一個類中定義多個同名的方法，但要求每個方法具有不同的參數(shù)的類型或參數(shù)的個數(shù)。調(diào)用重載方法時，Java編譯器能通過檢查調(diào)用的方法的參數(shù)類型和個數(shù)選擇一個恰當?shù)姆椒ā７椒ㄖ剌d通常用于創(chuàng)建完成一組任務(wù)相似但參數(shù)的類型或參數(shù)的個數(shù)或參數(shù)的順序不同的方法。 Java的方法重載，就是在類中可以創(chuàng)建多個方法，它們可以有相同的名字，但必須具有不同的參數(shù)，即或者是參數(shù)的個數(shù)不同，或者是參數(shù)的類型不同。調(diào)用方法時通過傳遞給它們的不同個數(shù)和類型的參數(shù)，以及傳入?yún)?shù)的順序來決定具體使用哪個方法。

看上面復雜的概念一時可能看不懂不如我來舉一個例子吧。

好比如我們要實現(xiàn)數(shù)的加法，要同時實現(xiàn)兩個整形的加法，兩個浮點數(shù)的加法，三個整形數(shù)的加法

我們沒學過方法重載可能會這么寫。

  public static int addTwoInt(int a,int b) {
        return a+b;
    }
    public static int addThirdInt(int a,int b,int c) {
        return a+b+c;
    }
    public static double addTwoDouble(double a,double b) {
        return a+b;
    }
    public static void main(String[] args) {
        int a =10;
        int b =20;
        int c =20;
        double d =3.14;
        double e =9.89;
        System.out.println(addTwoInt(a, b));
        System.out.println(addThirdInt(a, b, c));
        System.out.println(addTwoDouble(d, e));
 
    }

對于學過方法重載的同學看見這個代碼真想。。。。。

這樣的代碼是不是看著很繁瑣，每一次實現(xiàn)一個加法就要起一個名。上面的代碼需要提供許多不同的方法名，而取名字本來就是讓人頭疼的事情

那我們接下來使用方法重載又有多大的變化呢？

我們都使用相同的名字在idea不會報錯，原因是在java語言中支持方法的重載。

所以，在Java中，如果多個方法的名字相同，參數(shù)列表不同，則稱該幾種方法被重載了

根據(jù)這三個代碼我們就可以總結(jié)出方法重載的規(guī)則了

第一：方法名相同；

第二：返回值不做要求；

第三：方法名的參數(shù)列表不同（包括參數(shù)的返回類型，形參的順序，形參的個數(shù)）；

方法簽名

既然有方法重載，那java是內(nèi)部是怎么支持重載的呢？那就要說一說方法簽名了。

方法簽名即：經(jīng)過編譯器編譯修改過之后方法最終的名字。具體方式：方法全路徑名+參數(shù)列表+返回值類型，構(gòu)成方法完整的名字。

我們通過找到生成代碼的.class文件 然后右鍵打開powershell

 輸入一個 javap -v +文件名 

 回車之后就可以看到j(luò)ava代碼的匯編代碼，根據(jù)匯編代碼就可以看到方法的簽名。

 我們既然定義了相同名字的方法，那編譯器是怎么識別我們要調(diào)用哪個方法呢？沒錯這就是方法簽名起了作用，每定義一個方法在編譯完生成class文件，就會生成一個方法簽名，編譯器就是根據(jù)每個方法的簽名不同而識別的，比如你要計算兩個double類型的和，那他就會直接找DD的這個簽名而不會匹配到其他的簽名。

遞歸

遞歸定義是數(shù)理邏輯和計算機科學用到的一種定義方式，使用被定義對象的自身來為其下定義（簡單說就是自我復制的定義）。遞歸定義(recursive definition)亦稱歸納定義，一種實質(zhì)定義，指用遞歸的方法給一個概念下的定義

通俗的講，當我們遇到一個問題，這個問題具有每一步的解法都是相同的，我們就可以將這個大問題分解成多個子問題，最終這個問題就會被解決；

實現(xiàn)遞歸有兩個必要條件：

第一：子問題必須要與原問題的解決方法是相同的。

第二：必須要有判斷條件防止遞歸深度太深導致棧溢出。

我們來舉一個經(jīng)典遞歸例子：求N的階乘

 我們可以思考一下根據(jù)上圖的推理第一：他符合原問題的解法與子問題的解法是一致的，有符合判斷條件（判斷條件就是如果n==1的時候1！=1）.這就是遞歸 從5！被分解成5*4！，4*3！.......

這樣的問題就迎刃而解了。

public static int factor(int n) {
        if(n==1) {
            return 1;
        }
        return n* factor(n-1);
    }
    public static void main(String[] args) {
        System.out.println(factor(5));
    }

 遞歸小練習

按順序打印一個數(shù)字的每一位(例如 1234 打印出 1 2 3 4)。

這個題我們怎么思考呢？

首先要得到一個數(shù)字的每一位肯定是除10 和模10循環(huán)知道數(shù)字為0

那我們可以將1234這樣來分解；

    public static void printEveryNum(int num) {
        if(num<=9) {
            System.out.print(num+" ");
            return;
        }
        printEveryNum(num/10);
        System.out.print(num%10+" ");
    }
    public static void main(String[] args) {
        int num =1234;
        printEveryNum(num);
    }

遞歸求 1 + 2 + 3 + ... + 10  遞歸實現(xiàn)1一直加到10的和

    public static int sum(int num) {
        if(num==0) {
            return 0;
        }
        return num+sum(num-1);
    }
    public static void main(String[] args) {
        int a =10;
        System.out.println(sum(100));
    }

到此這篇關(guān)于全面分析Java方法的使用與遞歸的文章就介紹到這了,更多相關(guān)Java方法與遞歸內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論