方法 System.out.println();//是什麼嗎? //系統類+對象+方法 Java方法是一對語句的集合,他們一起負責執行一個功能方法是解決一類問題的步驟的有序組合方法包含於類或對象中方法在程式中被創建,在其他地方被引用設計原則: 方法本意是功能塊**(類似C語言的函數)**, ...

方法

System.out.println();//是什麼嗎?
//系統類+對象+方法

Java方法是一對語句的集合,他們一起負責執行一個功能
- 方法是解決一類問題的步驟的有序組合
- 方法包含於類或對象中
- 方法在程式中被創建,在其他地方被引用
設計原則: 方法本意是功能塊(類似C語言的函數), 就是實現某個功能的語句塊集合,設計方法最好保持方法的原子性,就是一個方法只完成1個功能,這樣有利於後期的擴展
命名規範: 首字母小寫+駝峰規則
方法都是寫在main外面的

package Method;

public class Demo_0 {
    public static void main(String[] args) {
        //調用了add方法
        			//實參
        int sum = add(1, 2);//int sum = add(1, 2);
        System.out.println(sum);
        //System.out.println(add(1, 2));
        System.out.println("======================================");

        //調用test
        test();
    }

    //加法					形式參數
    public static int add(int a, int b) {//有返回值需要int等類型
        return a + b;//返回值
    }

    //方法2
    public static void test() {//返回值為空void
        //while迴圈輸出1~1000之間被5整除的數,並且3個每行
        int i_1 = 0;
        while (i_1 <= 1000) {
            ++i_1;
            if (i_1 % 5 == 0) {
                System.out.print(i_1 + "\t\t");//不要加ln
            }    //println輸出後會自動換行
            if (i_1 % (5 * 3) == 0) {
                System.out.println();
            }
        }

    }

}
//此段代碼不顯示圖片, 自身去試試代碼

方法的定義

方法包含一個方法頭和一個方法體
- **修飾符: **是可選的, 讓編譯器知道如何調用方法, 並且定義了方法的訪問類型
- 返回值類型: 方法會有返回值, return ValueType是方法返回值的數據類型;,修飾符中需要使用static; 倘若方法無需返回值, 需要使用關鍵字void
- **方法名: **方法的實際名稱, 方法名和參數表共同構成方法簽名
- **參數類型: **參數類似一個占位符, 當方法需要調用時, 傳遞給參數, 這個值被稱為實參或者變數;參數列表是指方法的參數類型、順序和參數的個數; 參數是可選的,意思就是方法名可以不包含任何參數
  - 形式參數: 在方法被調用時用於接收外界輸入的數據(類似add(int a, int b)中的a與b)
  - 實參: 調用方法的時實際傳遞給方法的數據(類似add(1, 2)中的1與2)
- **方法體: **方法體包含具體的語句、定義方法的功能
```
修飾符 返回值類型 方法名(參數類型 參數名){
    //修飾符包含了static或者void
	...
	方法體
	...
	return 返回值;
}
```

方法調用

```
//對象名.方法名(實參列表)
```
Java支持調用方法的方式有兩種,根據方法是否返回值來選擇
當方法返回一個值的時候, 方法調用通常直接當作一個值
- ```
    int larger = Max(30, 40);
```
若返回值時void, 方法調用是一條語句
Java是值傳遞(暫且知道就行)

package Method;

import java.util.Scanner;

public class Demo_1 {
    public static void main(String[] args) {
        System.out.println("比誰大");
        System.out.print("Input Number_1: ");
        Scanner Input = new Scanner(System.in);//創建一個名字"Input"的掃描器
        int Number_1 = Input.nextInt();//用next方法接收
        //nextInt()接收int類型的數值
        //
        System.out.print("Input Number_2: ");
        Scanner Input2 = new Scanner(System.in);//創建一個名字"Input"的掃描器
        int Number_2 = Input2.nextInt();
        System.out.println("\t兩個數中這個最小: " + Max(Number_1, Number_2));
        System.out.println("============================================");
        System.out.println("比誰小");
        System.out.print("Input Number_3: ");
        Scanner Input_Num3 = new Scanner(System.in);//創建一個名字"Input"的掃描器
        int Number_3 = Input.nextInt();//用next方法接收
        //nextInt()接收int類型的數值
        
        System.out.print("Input Number_4: ");
        Scanner Input_Num4 = new Scanner(System.in);//創建一個名字"Input"的掃描器
        int Number_4 = Input2.nextInt();
        System.out.println("\t兩個數中這個最小: " + Min(Number_3, Number_4));
    }

    //兩個數比大小,輸出大的
    public static int Max(int a, int b) {
        if (a == b) {
            System.out.println("\tNumber_1 == Number_2");
            //return 0; //終止方法
            return a;
        } else if (a > b) {
            System.out.println("\t兩個數中Number_1最大");
            return a;
        } else {
            System.out.println("\t兩個數中Number_2最大");
            return b;
        }
    }
    //

    //兩個數比大小,輸出小的
    public static int Min(int x, int y) {
        if (x == y) {
            System.out.println("\tNumber_3 == Number_4");
            return x;
        } else if (x < y) {
            System.out.println("\t兩個數中Number_3最小");
            return x;
        } else {
            System.out.println("\t兩個數中Number_4最小");
            return y;
        }
    }
    //
}

方法重載

重載就是在一個類中,有相同函數名稱, 但形參不同的函數
重載規則
- 方法名必須相同
- 參數列表必須不同(個數, 類型, 參數排列順序不同等)
- 方法返回的類型可相同也可不通
- 僅僅返回類型不同不足以成為方法重載
實現理論: 方法名稱相同時,編譯器會根據調用方法的參數個數,參數類型等逐個匹配, 以選擇對應的方法,如果匹配失敗,則編譯器報錯
重載與返回值無關(返回類型可相同也可不同)

package Method;

import java.util.Scanner;

public class Demo_1 {
    public static void main(String[] args) {
        //System.out.println("比誰大");
        //System.out.print("Input Number_1: ");
        //Scanner Input = new Scanner(System.in);//創建一個名字"Input"的掃描器
        //int Number_1 = Input.nextInt();//用next方法接收
        ////nextInt()接收int類型的數值
        //
        //System.out.print("Input Number_2: ");
        //int Number_2 = Input.nextInt();
        //System.out.println("\t兩個數中這個最小: " + Max(Number_1, Number_2));
        //Input2.close();
        //Input.close();
        //System.out.println("==============================================");
        //System.out.println("比誰小");
        //System.out.print("Input Number_3: ");
        //Scanner Input = new Scanner(System.in);//創建一個名字"Input"的掃描器
        //int Number_3 = Input.nextInt();//用next方法接收
        ////nextInt()接收int類型的數值
        //
        //System.out.print("Input Number_4: ");
        //int Number_4 = Input.nextInt();
        //System.out.println("\t兩個數中這個最小: " + Min(Number_3, Number_4));
        //Input_Num3.close();
        //Input_Num4.close();
        ///////////////////
        System.out.println("比誰大");
        System.out.print("Input Number_1: ");
        Scanner Input = new Scanner(System.in);//創建一個名字"Input"的掃描器
        double Number_1 = Input.nextDouble();//用next方法接收
        //nextInt()接收int類型的數值

        System.out.print("Input Number_2: ");
        double Number_2 = Input.nextDouble();//若nextDouble變為nextInt不會出崔,但最後結果會跟隨最開頭的Double
        System.out.println("\t兩個數中這個最小: " + Max(Number_1, Number_2));
        Input.close();
        Input2.close();
    }


    //兩個數比大小,輸出大的
    public static int Max(int a, int b) {
        if (a == b) {
            System.out.println("\tNumber_1 == Number_2");
            //return 0; //終止方法
            return a;
        } else if (a > b) {
            System.out.println("\t兩個數中Number_1最大");
            return a;
        } else {
            System.out.println("\t兩個數中Number_2最大");
            return b;
        }
    }

    public static double Max(double a, double b) {//針對Max()方法的重載;返回double類型
        if (a == b) {
            System.out.println("\tNumber_1 == Number_2");
            //return 0; //終止方法
            return a;
        } else if (a > b) {
            System.out.println("\t兩個數中Number_1最大");
            return a;
        } else {
            System.out.println("\t兩個數中Number_2最大");
            return b;
        }
    }
    //


    //兩個數比大小,輸出大的
    public static int Min(int x, int y) {
        if (x == y) {
            System.out.println("\tNumber_3 == Number_4");
            return x;
        } else if (x < y) {
            System.out.println("\t兩個數中Number_3最小");
            return x;
        } else {
            System.out.println("\t兩個數中Number_4最小");
            return y;
        }
    }
    //
}

註釋了的代碼可全部解開, 試試輸入的double類型和int類型的,最後輸出若有.0就是double類型;註意更改我代碼中Scanner等變數

命令行傳參(可以簡單瞭解)

以下代碼是需要在java文件的路徑下用cmd進行編譯,參考Hello.java
以下代碼需要用更改編碼格式才可編譯

javac -encoding utf8 CmdTran.java
     //編碼格式

package Method;//註意自己的包名

public class CmdTran {//註意自己的文件名
    public static void main(String[] args) {
        //命令行傳參
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

cmd視窗解析
- 在java文件的所在路徑下編譯java文件
- cd ../回退上一級文件夾(可以體會下在其他文件下引用自己寫的java文件)
- 運行編譯好的java文件(為何沒有輸出, 因為我們的java代碼是需要將參數輸出, 我並沒有參數輸入)
- 再一次運行java文件, 在java Method.CmdTran輸入四個參數I am your Father
- 輸出了四個剛剛輸入的參數(數組下標由0開始)

可變參數(不定項參數)

在JDK 1.5開始, Java支持傳遞同類型的可變參數給一個方法
方法聲明中, 在指定參數類型後加一個省略號(...)
一個方法中只能指定一個可變參數, 它必須是方法的最後一個參數; 任何普通的參數必須在它之前聲明
在一開始寫方法時,會有很多不確定變數, 我們需要寫多種方法(方法重載), 而每種方法都是只實現一個功能,依次針對不同情況

package Method;

public class ChangeData {
    public static void main(String[] args) {
        ChangeData cd = new ChangeData();//創建類的對象
        cd.test(1.5F, 222, 3, 2);//創建一個對象cd, 並使用類中的test方法
    }		  //x:1.5 i:222, 3, 2

    public void test(float x, int... i) {
        //不知道要傳入多少參數
        System.out.println(x + " " + i[0] + " " + i[2]);
    }
}

變長參數是 Java 的一個語法糖，本質上還是基於數組的實現：

package Method;

public class ChangeData {
    public static void main(String[] args) {
        printMax(21, 25, 2, 56);
        printMax(new double[]{1, 2, 5, 6, 7, 8, 9});//本質是數組因此可以用數組形式
    }
    public static void printMax(double... number) {
        if (number.length == 0) {//當數組長度=0
            System.out.println("No argument passed");
            return;
        }

        double max = number[0];//初始化
        //找出最大值
        for (int i = 1; i < number.length; i++) {
            if (number[i] > max) {
                max = number[i];
            }
        }
        System.out.println("The Max value is " + max);
    }
}

遞歸

A方法調用A方法! 自己調用自己
思想: 簡單程式解決複雜問題; 把大型複雜的問題層層轉化為一個與原問題相似的規模較小問題來求解
遞歸結構: 遞歸頭就是啥時候不調用自己,如果沒有就陷入死迴圈
遞歸結構: 遞歸體就是啥時候調用自身方法
雖然代碼量簡單且少,但會占用很多空間

package Method;

public class InterJava {
    public static void main(String[] args) {
        InterJava inter = new InterJava();
        // 沒有遞歸頭, 寫會錯誤(棧溢出)
        System.out.println(inter.f(5));
    }

    //5! = 1*2*3*4*5
    public static int f(int n) {
        if (n == 1) {//遞歸頭
            return 1;
        } else {//遞歸體
            return n * f(n - 1);
        }
    }
}

遞歸: 本質就是當我調用時, 只要我調用方法時沒用到遞歸頭的條件我就必須使用遞歸體語句從而不斷縮小了問題的本質, 當進行遞歸體語句時,就可以將遞歸體語句的結果不斷返回上去

計算器實現

計算器,實現加減乘除,並能迴圈接收新數據,通過交互實現

package Method;//註意包名

import java.util.Scanner;//創建輸入對象需要的包

public class Counter {//註意類名
    public static void main(String[] args) {
        //計算器,實現加減乘除,並能迴圈接收新數據,通過交互實現
        /*
        寫4個方法:
        加減乘除
        利用迴圈+ switch進行用戶交互
        傳遞需要操作的兩個數
        輸出結果
         */
        Scanner scanner = new Scanner(System.in);//創建輸入
        String m = "Y";//初始化迴圈條件
        while (m.equals("Y")) {
            System.out.print("請輸入第一個數:");//輸入數值
            int x = scanner.nextInt();

            System.out.print("請輸入運算符:");//輸入運算符,作為switch條件
            String o = scanner.next();

            System.out.print("請輸入第二個數:");//輸入數值
            int y = scanner.nextInt();

            int result = 0;//初始化結果變數

            switch (o) {//根據運算符變數,選擇一個case
                case "+":
                    result = Add(x, y);
                    break;
                case "-":
                    result = Sub(x, y);
                    break;
                case "*":
                    result = Mul(x, y);
                    break;
                case "/":
                    result = Div(x, y);
                    break;
                default:
                    System.out.print("輸入錯誤");
            }
            
            System.out.println(x + o + y + "=" + result);

            System.out.print("是否繼續下一組計算(Y/N): ");
            m = scanner.next();//重新定義迴圈條件;輸入N就跳出while
        }
        scanner.close();//關閉IO
        System.out.println("老子寫的計算器牛逼吧!!!");
    }

    //加減乘除的方法定義
    public static int Add(int a, int b) {
        return a + b;
    }

    public static int Sub(int c, int d) {
        return c - d;
    }

    public static int Mul(int e, int f) {
        return e * f;
    }

    public static int Div(int g, int h) {
        return g / h;
    }
}

計算器可以對其數據類型更改為double類型, 讓其除法運算有更高的精度;
思路:
1. 對加減乘除方法進行編寫
2. 思考利用什麼條件來對switch條件進行判斷運算選擇(利用運算符)
3. 由於條件需要迴圈不斷接收數值, 所以利用while語句的判定, 並且在一次迴圈結尾重新定義while語句的判定,判斷是否再一次進行二元運算

本文來自博客園，作者：Wo_OD，轉載請註明原文鏈接：https://www.cnblogs.com/WoOD-outPut/p/17035921.html