方法的重载和递归

一、方法

方法就是一个代码片段。

方法定义语法

    public static 方法返回值 方法名称（参数类型 参数名称...）

方法的调用

    public static void main(String[] args){
       int x = 10;
       int y = 20;
       //方法的调用
       int ret = add(x,y);
    }
    public statuc int add(int a,int b){
       //return表示返回值
       return a+b;
    }

方法返回值

一个方法可以有返回值也可以没有，根据当前这个方法的使用判断，没有返回值用void来声明，当没有返回值的方法中使用return，表示当前方法结束调用，后面的代码不再执行。

二、重载

方法重载表示一组方法的方法名称完全相同，参数的个数或者类型不同，与方法返回值无关。重载表示发生在同一类中的不同方法。

     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;
     }

方法的参数传递

Java中的参数传递只有值传递

例题：交换两个整型变量

    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;
    }

运行结果为：a=10 b=20

没有进行数值交换，只是进行了赋值

要进行数值交换有如下方法：传引用类型参数

    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;
    }

运行结果为：a=20 b=10

三、递归

一个方法在执行过程中调用自身，就称为“递归”。

递归的使用场景：

1、一个大问题可以拆分为若干个子问题。

2、原问题和子问题除了数据规模不一样，求解思路完全一样。

3、存在递归终止条件。

 例：递归求N的阶乘。

    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n){
        //先写终止条件
        if(n == 1){
            return 1;
        }
        return n * factor(n-1);
    }

递归如图所示，先进行递再进行归，按图中的标识1->8的顺序执行。

递归练习题 

例1：按顺序打印一个数字的每一位（例如1234打印出 1 2 3 4）。

    public static void main(String[] args) {
        int num = 1234;
        print(num);
    }
    public static void print(int num){
        if (num > 10){
            print(num / 10);
        }
         System.out.print(num % 10 + " ");
    }

例2：输入一个整数，按倒序打印每一位数（例如1234打印出 4 3 2 1）。

    public static void main(String[] args) {
        int num = 1234;
        nunPrint(num);
    }

    public static void nunPrint(int num){
        //若当前数只有个位，直接输出
        if (num < 10){
            System.out.print(num + " ");
            return;
        }
        //先输出当前数的个位，模10当前数的求个位
        System.out.print(num % 10 + " ");
        //再除10，为了分别求上述当前数的百位、千位等等
        nunPrint(num /10);
    }

例3：求斐波那契数列的第N项。

斐波那契数列：

n=1，fib(1)=1；

n=2，fib(2)=1；

n=3，fib(3)=fib(1)+fib(2)；

n=4，fib(4)=fib(2)+fib(3)；

...

n=n，fib(n)=fib(n-2)+fib(n-1)；

    public static void main(String[] args) {
        int n = 20;
        System.out.println(fib(20));
    }
    public static int fib(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        return fib(n-2) + fib(n-1);
    }

代码运行结果为：6765

斐波那契数列用递归会出现冗余运算，所以使用循环方法：

    public static void main(String[] args) {
        int n = 20;
        System.out.println(fib(20));
        System.out.println(fib1(20));
    }
    public static int fib1(int n){
        int last1 = 1;
        int last2 = 1;
        int cur =0;
        for (int i = 3; i <= n; i++) {
            cur = last1 + last2;
            last2 = last1;
            last1 = cur;
        }
        return cur;
    }

代码运行结果为：6765

所以，斐波那契数列的相关问题，应该选择循环的方法。