一、什麼是方法？

　　在日常生活中，方法可以理解為要做某件事情，而採取的解決方法

　　比如：小明剛出家門，要去學校上課，這就面臨一個問題需要解決，小明應該怎麼去學校呢？有什麼解決辦法嗎？

　　可以採用坐公交車或者走路又或者坐計程車的方法去學校，那麼，這種解決某件事情的辦法，就稱之為方法

　　在Java中，方法就是用來解決某件事情或實現某個功能的程式碼塊

　　方法的實現過程中，會包含很多語句用於完成某個特定功能---通常是處理文字，控制輸入或計算數值

二、方法的語法格式？

　　修飾符 返回值型別 方法名（引數型別 引數名1，引數型別 引數名2...）{

　　　　方法體（多個執行語句）;

　　　　...

　　　　return 返回值;

　　}

　　修飾符：方法的修飾符有很多，有對訪問許可權進行限定的（private，public等），有靜態修飾符static，還有最終修飾符final等，這些老師暫時沒講，就先記著public static

　　返回值型別：用於限定返回值的資料型別

　　方法名：一個名字，但取名最好要有意義，儘量用英文，不要用拼音。為了方便我們呼叫方法

　　引數型別：用於接收呼叫方法時傳入的資料的型別

　　引數名：用於接收呼叫方法時傳入的資料的變數

　　方法體：實現該功能的程式碼

　　return：結束方法，將返回值帶給呼叫者

　　例如：定義一個方法，計算兩個整數的和，並輸入這個結果

 1 package com.cnblogs;
 2 
 3 public class MethodDemo {
 4     public static void main(String[] args) {
 5         int c = sum(5, 6);
 6         System.out.println("這兩個數的和為：" + c);
 7     }
 8     
 9     public static int sum(int a, int b) {
10         int c = 0;
11         c = a + b;
12         return
 
 c;
13     }
14 }

　　結果為：這兩個數的和為：11

三、方法呼叫的記憶體圖

　　分析：

　　1. 類，以及類的一系列方法都時存放在方法區中

　　2. main方法是程式的入口，執行main方法，將方法區的main方法載入到棧區中，建立一個int型別的變數c

　　3. 呼叫sum()方法，並將sum方法返回的值賦給變數c。呼叫sum()方法時，從方法區將sum方法載入到棧區

　　4. 建立兩個形參變數a和b，由於呼叫sum方法時傳了兩個實參5和6，分別對應賦值a和b

　　5. 建立區域性變數c，進行運算，將a+b的和賦給c，並且將結果c返回給呼叫者，此時sum方法結束，消棧，將棧區的sum方法清除，節約記憶體

　　6. 將sum(5, 6)方法返回的值賦給區域性變數c（這個c是main方法中的區域性變數），使用輸出語句列印c的值，此時main方法結束，消棧，將棧區的sum方法清除，節約記憶體

四、void關鍵字

　　如果一個方法沒有明確的返回值，則使用返回值型別使用void代替

 1 package com.cnblogs;
 2 
 3 public class MethodDemo {
 4     public static void main(String[] args) {
 5         int x = 5;
 6         int y = 6;
 7         printNum(x, y);
 8     }
 9     
10     public static void printNum(int a, int b) {
11         System.out.println("a的值為：" + a + "\n" + "b的值為：" + b);
12     }
13 }

　　結果為：a的值為：5

　　　　　　b的值為：6

五、方法有哪幾種方式？

　　1）有參有返回值

　　2）有參無返回值

　　3）無參有返回值

　　4）無參無返回值

 1 package com.cnblogs;
 2 
 3 public class MethodDemo {
 4     public static void main(String[] args) {
 5         
 6     }
 7     //有參有返回值
 8     public static int sum(int a, int b) {
 9         return a + b;
10     }
11     //有參無返回值
12     public static void printNum(int a) {
13         System.out.println("值為：" + a);
14     }
15     //無參有返回值
16     public static int returnNum(){
17         return 3;
18     }
19     //無參無返回值
20     public static void helloWorld() {
21         System.out.println("Hello World!");
22     }
23 }

六、方法的呼叫有幾種方式？

　　1）單獨呼叫　　->　　沒有返回值的方法使用這種呼叫方式

　　2）賦值呼叫　　->　　有返回值的方法呼叫方式

　　3）輸出呼叫　　->　　有返回值的方法呼叫方式

 1 package com.cnblogs;
 2 
 3 public class MethodDemo {
 4     public static void main(String[] args) {
 5         //單獨呼叫
 6         helloWorld();
 7         //賦值呼叫，通常用於如果後續還需要對這個結果進行處理的話，就使用這種方式
 8         int a = returnNum();
 9         //輸出呼叫
10         printNum(5);
11     }
12     //有參有返回值
13     public static int sum(int a, int b) {
14         return a + b;
15     }
16     //有參無返回值
17     public static void printNum(int a) {
18         System.out.println("值為：" + a);
19     }
20     //無參有返回值
21     public static int returnNum(){
22         return 3;
23     }
24     //無參無返回值
25     public static void helloWorld() {
26         System.out.println("Hello World!");
27     }
28 }

七、方法的過載

　　在同一個類中具有多個重名的方法叫做方法過載，方法過載是讓類以統一的方式處理不同型別資料的一種手段

　　具備過載的三個條件：

　　　　1）在同一個類中

　　　　2）方法名必須相同

　　　　3）方法的引數列表不同（引數型別不同或者引數個數不同，與返回值型別沒有關係）

　　擴充套件：

　　　　1）和成員方法一樣，構造方法也可以過載

　　　　2）宣告為final的方法不能被過載

 1 package com.cnblogs;
 2 
 3 public class MethodDemo {
 4     public static void main(String[] args) {    
 5         System.out.println(sum(6.0, 7.3));
 6         System.out.println(sum(6, 7));
 7     }
 8     
 9     public static int sum(int a, int b) {
10         return a + b;
11     }
12     public static double sum(double a, double b) {
13         return a + b;
14     }
15 }

八、方法的引數列表

　　如果是基本型別　　->　　實際傳遞的是數值，形參的改變不會影響實參

　　如果是引用型別　　->　　實際傳遞的是地址值，形參的改變會影響實參

　　1）基本型別時？

 1 public class ArgsDemo {
 2     public static void main(String[] args) {
 3         // 定義變數
 4         int a = 10;
 5         int b = 20;
 6         System.out.println("a:" + a + ",b:" + b);// a:10,b:20
 7         change(a, b);
 8         System.out.println("a:" + a + ",b:" + b);// a:10,b:20
 9     }
10 
11     public static void change(int a, int b) { // a=10,b=20
12         System.out.println("a:" + a + ",b:" + b);// a:10,b:20
13         a = b; // a=20;
14         b = a + b;// b=40;
15         System.out.println("a:" + a + ",b:" + b);// a:20,b:40
16     }
17 
18 }

　　2）引用型別時？

 1 public class ArgsDemo2 {
 2     public static void main(String[] args) {
 3         int[] arr = { 1, 2, 3, 4, 5 };
 4         for (int x = 0; x < arr.length; x++) {
 5             System.out.println(arr[x]);//1,2,3,4,5
 6         }
 7         change(arr);
 8         for (int x = 0; x < arr.length; x++) {
 9             System.out.println(arr[x]);//1,4,3,8,5
10         }
11     }
12 
13     public static void change(int[] arr) {
14         for (int x = 0; x < arr.length; x++) {
15             //如果陣列元素是偶數，值就變成了以前的2倍
16             if (arr[x] % 2 == 0) {
17                 arr[x] *= 2;
18             }
19         }
20     }
21 }

九、方法的遞迴

　　其實就是方法自己呼叫自己

　　遞迴的前提：

　　　　1）定義的方法的呼叫次數不能太多，否則容易棧記憶體溢位錯誤

　　　　2）該方法必須要有一個結束條件

　　例如：求5的階乘 5! = 5 * 4 * 3 * 2 * 1

 1 public class Test10 {
 2 
 3     public static void main(String[] args) {
 4         int num = jc(5);
 5         System.out.println(num);
 6     }
 7 
 8     // 1:出口條件 如果1 return 1
 9     // 如果不是1 return num*方法名(num-1)
10     public static int jc(int num) {
11         if (num == 1) {
12             return 1;
13         } else {
14             return num * jc(num - 1);
15         }
16     }
17 }

　　例如：不死神兔（斐波那契數列），有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子漲到第三個月後每個月又生一堆兔子，假如兔子不死，問第二十個月的兔子對數是多少？

　　　　解法一：使用陣列來做

 1 package com.cnblogs;
 2 
 3 public class Rabbit {
 4     public static void main(String[] args) {
 5         int[] arr = new int[20];
 6         //第一個月和第二個月的兔子對數
 7         arr[0] = 1;
 8         arr[1] = 1;
 9         
10         //從第三個月開始
11         for(int x = 2; x < arr.length; x++) {
12             arr[x] = arr[x - 1] + arr[x - 2];
13         }
14         
15         System.out.println("第二十個月的兔子對數時：" + arr[19]);
16     }
17 }

　　　　解法二：遞迴思想

 1 public class Demo7 {
 2     public static void main(String[] args) {
 3         System.out.println(getCount(20));
 4     }
 5     
 6     public static int getCount(int m) {
 7         if(m == 1 || m == 2) {
 8             return 1;
 9         }else {
10             return getCount(m-1) + getCount(m-2);
11         }
12     }
13 }