[JavaSE] 方法

方法的基本用法

什么是方法

方法就是一个代码片段. 类似于 C 语言中的 “函数”

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单

举个例子：实现一个方法实现两个整数相加

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
    // 方法的调用
        int ret = add(a, b);
        System.out.println("ret = " + ret);
    }
    // 方法的定义
    public static int add(int x, int y) {
        return x + y;
    }
}

1. 方法定义时, 参数可以没有. 每个参数要指定类型
2. 方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
3. 方法定义时的参数称为 “形参”, 方法调用时的参数称为 “实参”.
4. 方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可

实参和形参的关系

让我们看一个例子：

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("a = " + a + " b = " + b);
    }
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
    }
}

代我们看此代码, 没有完成数据的交换.
原因：对于基础类型来说, 形参相当于实参的拷贝. 即传值调用

解决办法: 传引用类型参数 (例如数组来解决这个问题)

public class Solution {
    public static void main(String[] args) {
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("a = " + arr[0] + " b = " + arr[1]);
    }
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}

当参数为基本数据类型时，传递的是值（拷贝或元素的内容）。形参的改变不会影响实参。
当参数为引用数据类型，传递的是地址值（引用）。形参的改变会影响实参。

方法的重载

优点：

• 解决了起名麻烦的问题
• 调用者不用记住太多的方法名

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
        double a3 = 10.5;
        double b3 = 10.5;
        double c3 = 20.5;
        double ret3 = add(a3, b3, c3);
        System.out.println("ret3 = " + ret3);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }
}

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数
字相加。
同一个方法名字, 提供不同版本的实现, 称为方法重载.
注：参数列表的数据类型或参数个数或参数的顺序，至少有一样不同。

重载的规则

对于同一个类：

• 方法名相同
• 方法的参数不同(参数个数或者参数类型)
• 方法的返回值类型不影响重载

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(int x, int y) {
        return x + y;
    }
}

当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载

方法递归

一个方法在执行过程中调用自身, 就称为 “递归”
举个例子：递归求N的阶乘

public class Solution {
    public static void main(String[] args) {
        int n = 3;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
        if (n == 1) {
            return 1;
        }
        int ret = n * factor(n - 1);
        return ret;
    }
}

执行过程图