目录

1.方法的重载

1.1为什么需要方法重载

1.2方法重载概念

1.3方法签名

2. 递归

2.1递归的概念

2.2递归执行过程分析

2.3递归练习

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

（2）递归求 1 + 2 + 3 + ... + 10

（3）写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19

（4）求斐波那契数列的第 N 项

2.4递归的效率为什么不高

---

  

1.方法的重载

1.1为什么需要方法重载

先来实现一个求两个整数的和的方法。

public static int add(int n , int k) {
     return n + k;
}
 
public static void main(String[] args) {
     int x = 10;
     int y = 20;
     int ret1 = add(x, y);
     System.out.println(ret1);
}

代码结果：

现在需求变了，需要求两个小数的两个整数的和。如果直接调用之前的整数加法函数的话就会出现错误。

public static int add(int n , int k) {
     return n + k;
}
   
public static void main(String[] args) {
     int x = 10;
     int y = 20;
     int ret1 = add(x, y);
     double a = 12.5;
     double b = 13.4;
     double ret2 = add(a, b);
     System.out.println(ret1);
     System.out.println(ret2);
}

一个方法的参数个数个数必须相同，返回类型也必须一致，这才是一个正确的方法。

上面代码计算小数和的时候，调用了整数加法的方法，类型明显不一致，所以才会报错。

如果要解决的话，就需要写一个小数加法的方法。

public static int addInt(int n , int k) {
     return n + k;
}
 
public static double addDouble(double n , double k) {
     return n + k;
}
 
public static void main(String[] args) {
     int x = 10;
     int y = 20;
     int ret1 = addInt(x, y);
     double a = 12.5;
     double b = 13.4;
     double ret2 = addDouble(a, b);
     System.out.println(ret1);
     System.out.println(ret2);
}

代码结果：

需求虽然是解决了，但是需要提供许多不同的方法名，而取名字本来就是让人头疼的事情。那能否将所有的名字都给成 add 呢？

1.2方法重载概念

在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了
 

    public static int play(int x, int y) {
        return x > y ? x : y;
    }
 
    public static double play(double x, double y) {
        return x > y ? x : y;
    }
 
    public static double play(double x, double y, double z) {
        double MaxDouble = x > y ? x : y;
        return MaxDouble > z ? MaxDouble : z;
    }
 
    public static void main(String[] args) {
        int ret1 = play(10, 20);
        double ret2 = play(12.2,12.3);
        double ret3 = play(1.1, 1.2, 1.3);
        System.out.println(ret1);
        System.out.println(ret2);
        System.out.println(ret3);
    }

代码结果：

 可以看到上面代码的三个方法名称相同，调用的时候名称也相同，只是参数和返回类型不相同。

注意：

1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关
4. 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法参数的类型一定不能相同
    

现在来解决上面求小数加法的问题。

public static int add(int n , int k) {
     return n + k;
}
 
public static double add(double n , double k) {
     return n + k;
}
 
public static void main(String[] args) {
     int x = 10;
     int y = 20;
     int ret1 = add(x, y);
     double a = 12.5;
     double b = 13.4;
     double ret2 = add(a, b);
     System.out.println(ret1);
     System.out.println(ret2);
}

代码结果：

1.3方法签名

方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
 

public static int sum(int x, int y){
     return x + y;
}
public static double sum(double x, double y){
     return x + y;
}
public static void main(String[] args) {
     System.out.println(sum(1, 2));
     System.out.println(sum(1.5, 2.5));
}

代码结果：

 上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：

1. 先对工程进行编译生成.class字节码文件
2. 在控制台中进入到要查看的.class所在的目录
3. 输入：javap -v 字节码文件名字即可

2. 递归

2.1递归的概念

一个方法在执行过程中调用自身, 就称为 "递归"

递归有一个起始条件, 有一个递推公式.
例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!
 

递归的必要条件

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
2. 递归出口
    

代码示例：求n的阶乘

public static int fac(int num) {
     if (num == 1) {//1的阶乘就是1 - 直接返回1就可以
         return 1;
     } else {
         //大于1的情况
         int recur = num * fac(num - 1);//调用自身
         return recur;
     }
}
 
public static void main(String[] args) {
     int num = 3;
     int ret = fac(num);
     System.out.println(ret);
}

代码结果：

2.2递归执行过程分析
 

求n的阶乘

public static int factor(int n) {
        System.out.println("函数开始, n = " + n);
        if (n == 1) {
            System.out.println("函数结束, n = 1 ret = 1");
            return 1;
        }
        int ret = n * factor(n - 1);
        System.out.println("函数结束, n = " + n + " ret = " + ret);
        return ret;
}
 
public static void main(String[] args) {
        int n = 3;
        int ret = factor(n);
        System.out.println("ret = " + ret);
}

代码结果：

 

执行过程图：

2.3递归练习
 

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

public static void add(int n) {
        if (n > 9) {
            add(n / 10);
        }
        System.out.println(n % 10);
}
 
    public static void main(String[] args) {
        int n = 123;
        add(n);
}

代码结果：

 

（2）递归求 1 + 2 + 3 + ... + 10

public static int func(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n + func(n - 1);
        }
}
 
public static void main(String[] args) {
     int num = 10;
     int ret = func(num);
     System.out.println(ret);
}

代码结果：

（3）写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19

public static int sum(int num) {
     if (num <= 9) {
         return num;
     }else {
         return num % 10 + sum(num / 10);
     }
}
 
public static void main(String[] args) {
     int n = 123;
     int ret = sum(n);
     System.out.println(ret);
}

代码结果：

（4）求斐波那契数列的第 N 项
 

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

代码结果：

 

2.4递归的效率为什么不高

 可以根据这张图看出，相同的次数调用了不止一次。每一次调用。都会进行一次运算，调用的多了，运算效率也就降低了。

注意：对于斐波那契数列来说不要使用递归来写

在解决斐波那契数列问题的时候，可以采用迭代（循环）来解决，效率回比递归块。并且以后在解决问题的时候，如果问题本身不是特别的复杂，就不建议使用递归，而是要使用迭代（循环）。