方法的重载(overload)，递归结构

一，方法的重载(overload)，

构成方法重载的条件：

1. 形参列表不同的含义：形参类型、形参个数、形参顺序不同

2. 只有返回值不同不构成方法的重载

   如：int a(String str){}与 void a(String str){}不构成方法重载

3. 只有形参的名称不同，不构成方法的重载

   如：int a(String str){}与int a(String s){}不构成方法重载

4. public class Test {
       public static void main(String[ ] args) {
           System.out.println(add(3, 5));// 8
           System.out.println(add(3, 5, 10));// 18
           System.out.println(add(3.0, 5));// 8.0
           System.out.println(add(3, 5.0));// 8.0
           // 我们已经见过的方法的重载
           System.out.println();// 0个参数
           System.out.println(1);// 参数是1个int
           System.out.println(3.0);// 参数是1个double
       }
       /** 求和的方法 */
       public static int add(int n1, int n2) {
           int sum = n1 + n2;
           return sum;
       }
       // 方法名相同，参数个数不同，构成重载
       public static int add(int n1, int n2, int n3) {
           int sum = n1 + n2 + n3;
           return sum;
       }
       // 方法名相同，参数类型不同，构成重载
       public static double add(double n1, int n2) {
           double sum = n1 + n2;
           return sum;
       }
       // 方法名相同，参数顺序不同，构成重载
       public static double add(int n1, double n2) {
           double sum = n1 + n2;
           return sum;
       }
       //编译错误：只有返回值不同，不构成方法的重载
       public static double add(int n1, int n2) {
           double sum = n1 + n2;
           return sum;
       }
       //编译错误：只有参数名称不同，不构成方法的重载
       public static int add(int n2, int n1) {
           double sum = n1 + n2;           
           return sum;
       }   
   }
   

   注：重载的方法，实际是完全不同的方法，只是名称相同而已

二，递归结构

1. 递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。
2. 递归的基本思想就是“自己调用自己”。

递归结构包括两个部分：

• 定义递归头。 解决：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
• 递归体。 解决：什么时候需要调用自身方法。

递归的缺陷

算法简单是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。