Java7方法

方法是什么

System.out.println()

System為類，out為對象，println()為方法

即調用系統System類里的標准輸出對象out中的println方法

 

Java方法是語句的集合，集合在一起執行一個功能

• 方法是解決一類問題的步驟的有序組合

• 方法包含於類或對象中

• 方法在程序中被創建，在其他地方被引用

public class Demo {
    //main方法
    public static void main(String[] args) {
        int sum = add(1,2);     //通過調用add方法，使a=1,b=2，並運行a+b
        System.out.println(sum);     //3
   }
​
    //加法
    public static int add(int a,int b){
        return a+b;
   }
}

 

設計方法的原則：方法本意是功能塊，即實現某個功能的語句塊集合

注意：設計方法時，最好保持方法的原子性，即一個方法只完成一個功能，這樣有利於程序后期的擴展

命名規則：首字母小寫，駝峰原則

 

方法的定義

Java的方法類似於其他語言的函數，是一段用以完成特定功能的代碼片段

一般情況，定義一個方法包含以下語法：

方法包含一個方法頭和一個方法體，一個方法的所有部分：

• 修飾符：修飾符，可選，告訴編譯器如何調用該方法，定義了該方法的訪問類型

• 返回值類型：方法可能會返回值。returnValueType是方法返回值的數據類型。有些方法執行所需的操作，但沒有返回值，這時returnValueType的關鍵字是void（空值）

• 方法名：是方法的實際名稱，方法名和參數表共同構成方法簽名

• 參數類型：參數像一個占位符。當方法被調用時，傳遞值給參數。這個值被稱為實參或者變量。參數列表是指方法的參數類型、順序和參數的個數。參數可選，方法可以不包含任何參數

  • 形式參數：方法被調用時用於接收外界輸入的數據

  • 實參：調用方法時實際傳給方法的數據

• 方法體：方法體包含具體的語句，定義該方法的功能

修飾符 返回值類型 方法名（參數類型 參數名）{
   ...
        方法體
   ...
    return 返回值;
}

 

參數類型：

public class Demo {
    //main方法
    //public(修飾符) void(返回值類型) main(方法名) (參數類型(string))
    public static void main(String[] args) {
        //實際參數：實際調用傳遞給方法的參數
        int sum = add(1,2);     //通過調用add方法，使a=1,b=2，並運行a+b
        System.out.println(sum);     //3
   }
​
    //加法
    //形式參數，用來定義作用的
    public static int add(int a,int b){
        return a+b;
   }
}

 

方法的調用

調用方法：對象名.方法名（實參列表）

Java支持兩種調用方法的方式，根據方法是否返回值來選擇

當方法返回一個值的時候，方法調用通常被當做一個值，例如：

int larger = max(30.40);

如果方法返回值是void，方法調用一定是一條語句

System.out.println("Hello,MyLove!");

public class Demo02 {
    public static void main(String[] args) {
        int max = max(1,1);
        System.out.println(max);
        
        hello();
   }
    
    //比大小，返回一個值
    public static int max(int a,int b){
        int result = 0;
        if ( a == b ){
            System.out.println("a==b");
            return 0;   //終止方法
       }
        if ( a > b ){
            result = a;
       }else {
            result = b;
       }
        return result;
   }
    
    //返回空值void
    public static void hello(){
        System.out.println("Hello,MyLove!");
   }
}

拓展了解：值傳遞（Java） 和 引用傳遞

 

方法的重載

重載即在一個類中，有相同的函數名稱，但形參不同的參數

 

方法的重載規則：

• 方法名稱不必須相同

• 參數列表必須不同（個數不同、或類型不同、或參數排列順序不同等）

• 方法的返回類型可以相同也可以不同

• 僅返回類型不同不足以成為方法的重載

public class Demo02 {
    public static void main(String[] args) {
        double max = max(3,1);
        System.out.println(max);
   }
    //比大小，方法名相同，參數類型不同
    public static int max(int a,int b){
        int result = 0;
        if ( a == b ){
            System.out.println("a==b");
            return 0;   //終止方法
       }
        if ( a > b ){
            result = a;
       }else {
            result = b;
       }
        return result;
   }
​
    public static double max(double a,double b){
        double result = 0;
        if ( a == b ){
            System.out.println("a==b");
            return 0;
       }
        if ( a > b ){
            result = a;
       }else {
            result = b;
       }
        return result;
   }
}

 

實現理論：

• 方法名稱相同時，編譯器會根據調用方法的參數個數、參數類型等去逐個匹配，以選擇對應的方法，若匹配失敗，則編譯器報錯

 

命令行傳參

有時希望運行一個程序時再傳遞給它消息。這要靠傳遞命令行參數main()函數實現

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

 

可變參數

Java支持傳遞同類型的可變參數給一個方法

方法聲明中，在指定參數類型后加一個省略號(...)

一個方法中只能指定一個可變參數，它必須是方法的最后一個參數

任何普通的參數都必須在它之前聲明

public class Demo04 {
    public static void main(String args[]) {
        //調用可變參數的方法
        printMax(12,3,2,2,56.2);
        printMax(new double[]{1,2,3});
   }
​
    public static void printMax(double... nums){
        if (nums.length == 0){
            System.out.println("No argument passed");
            return;
       }
​
        double result = nums[0];
​
        //排序
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > result){
                result = nums[i];
           }
       }
        System.out.println("The max value is " + result);
   }
}

 

遞歸

正常情況下，A方法調用B方法，main方法調用print方法

遞歸即：A方法調用A方法

利用遞歸可以用簡單的程序來解決一些復雜的問題

遞歸通常把一個大型復雜的問題層層轉化為一個與原問題相似的規模較小的問題來求解，遞歸策略只需少量的程序就可秒輸出解題過程所需要的多次重復計算，極大地減少了程序的代碼量

遞歸的能力在於用有限的語句來定義對象的無限集合

 

遞歸結構包括：

• 遞歸頭：何時不調用自身方法，若沒有頭，將陷入死循環

• 遞歸體：何時需要調用自身方法

階乘：

public class Demo05 {
    
    //遞歸思想
    public static void main(String args[]) {
        System.out.println(f(6));
   }
​
    public static long f(int i){
        if (i == 1){
            return 1;
       }else {
            return i * f(i - 1);
       }
   }
}

注意：能不用遞歸，盡量不用，遞歸只適合小數據計算，大數據會影響程序性能

 

實現一個控制台可循環單一加減乘除計算

public class Calculator {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        while (true) {
            if (calculator.count()) {

            } else {
                break;
            }
        }
    }

    boolean count() {
        Calculator calculator = new Calculator();
        System.out.println("請輸入第一個數字：");
        Scanner s1 = new Scanner(System.in);
        double a = s1.nextDouble();
        System.out.println("請輸入運算符：");
        Scanner s2 = new Scanner(System.in);
        String c = s2.nextLine();
        System.out.println("請輸入第二個數字：");
        Scanner s3 = new Scanner(System.in);
        double b = s3.nextDouble();
        switch (c) {
            case "+":
                double r1 = add(a, b);
                int i1 = (int) r1;
                if (i1 == r1) {
                    System.out.println(i1);
                } else {
                    System.out.println(r1);
                }
                break;
            case "-":
                double r2 = sub(a, b);
                int i2 = (int) r2;
                if (i2 == r2) {
                    System.out.println(i2);
                } else {
                    System.out.println(r2);
                }
                break;
            case "*":
                double r3 = mul(a, b);
                int i3 = (int) r3;
                if (i3 == r3) {
                    System.out.println(i3);
                } else {
                    System.out.println(r3);
                }
                break;
            case "/":
                double r4 = div(a, b);
                int i4 = (int) r4;
                if (i4 == r4) {
                    System.out.println(i4);
                } else {
                    System.out.println(r4);
                }
                break;
            default:
                System.out.println("輸入錯誤！");
                System.out.println("請重新輸入");
                calculator.count();
        }
        System.out.println("請問是否重新計算？");
        System.out.println("重新計算請輸入Y/y：");
        Scanner s = new Scanner(System.in);
        String t = s.next();
        if ("Y".equals(t) || "y".equals(t)) {
            return true;
        } else {
            System.out.println("Bye!");
            return false;
        }
    }


    double add(double a, double b) {
        return a + b;
    }


    double sub(double a, double b) {
        return a - b;
    }


    double mul(double a, double b) {
        return a * b;
    }


    double div(double a, double b) {
        if (b == 0) {
            System.out.println("null");
            return 0;
        } else {
            return a / b;
        }
    }
}