【JavaSE】方法的使用

方法的基本用法

什么是方法

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

意义：

1. 使代码可以被重复调用。
2. 是能够模块化的组织代码(当代码规模比较复杂的时候)。
3. 使代码更加简洁容易理解。
4. 直接调用现有方法，不必重复写入。

基本语法

// 方法定义
public static 方法返回值 方法名称（[参数类型 形参 ...]){
方法体代码;
[return 返回值];
}
// 方法调用
返回值变量 = 方法名称(实参...);

注：

1. 形参和实参的类型，个数要匹配。
2. 方法的返回值，和定义方法是方法的返回值要相同。

• Code: 实现一个方法实现计算1~n的和

    /**
     * 1~n的和
     * @param n
     * @return int
     */
    public  static int sum(int n){
        return  n * (n + 1) / 2;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int sum = sum(n);
        System.out.println("1~"+n+"的和为"+sum);
    }

    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
    }

注：

1. 方法定义时，可以没有参数，但每个参数要指定类型
2. 定义方法时，可以没有返回值，如果没有，则返回类型应写为void。
3. 方法在类的里面，代码可以在任意位置书写。
4. Java没有“函数声明”的概念。

方法的执行过程

基本规则：

• 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
• 当方法被调用的时候, 会将实参赋值给形参.
• 参数传递完毕后, 就会执行到方法体代码.
• 当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行.
• 一个方法可以被多次调用

**Code：**计算1！+ 2！+ …+ 5!

    public static void main(String[] args) {
        int n = 5;
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += factor(i);
        }
        System.out.println("sum = " + sum);
    }
    public  static int factor(int n){
        int ret = 1;
        while(n!= 0){
            ret *= n;
            n--;
        }
        return  ret;
    }

实参与形参的关系

在java中只有按值传递，没有按址传递,所以如果我们想要通过方法的调用来交换两个两个变量，应该使用传引用类型参数(例如：数组)代码如下：

    public static void main(String[] args) {
        int[] arr = { 1,2};
        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 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;
    }

这是因为编译器在编译期间，会对实参类型进行推演，根据其推演结果来决定调用那种方法。

方法名以及参数类型。这叫做方法的签名，返回类型不是方法签名的一部分

重载规则：

1. 方法名相同。
2. 方法的参数不同(个数或者类型)。
3. 方法的返回值不影响重载。

方法递归

概念： 方法 在执行 过程中调用自己的过程，加载递归

• 递归求N的阶乘

    public static int fac(int n){
        if(n == 1){
            return 1;
        }
        return  n * fac(n - 1);
    }

• 顺序打印12345

    public static void fun1(int n){
        if(n <= 9){
            System.out.print( n % 10 + " ");
        }else{
            fun1(n /10);
            System.out.print( n % 10 +" ");
        }
    }

• 求斐波那契数列的第 N 项

public static int fib(int n) {
	if (n == 1 || n == 2) {
	return 1;
	}
	return fib(n - 1) + fib(n - 2);
}

结论：

1. 有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效
2. 有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易