【方法递归学习】

一.方法

1.1 什么是方法(method)

方法就是一个代码片段. 类似于 C 语言中的 "函数"（方法定义出来就是为了“代码复用”）

1.2java中定义方法的语法：

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

//方法体代码

[return 语句]；//有返回值的方法才需要写return语句

}

【注意事项】

1. 修饰符：现阶段直接使用public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void

3. 方法名字：采用小驼峰命名

4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

5. 方法体：方法内部要执行的语句

6. 在java当中，方法必须写在类当中

7. 在java当中，方法不能嵌套定义

8. 在java当中，没有方法声明一说

public class MethodDefinition {
public static void main(String[] args) {
        //打印出1000-2000的所有闰年，并统计次数
        int count = 0;
        for (int i = 1000; i <= 2000; i++) {
            if (isLeapYear(i)) {//方法的调用
                System.out.println(i + "");
                count++;
            }
        }
        System.out.println("共有" + count + "个闰年");
}
        //定义一个判断年份是否为闰年的方法
    public static boolean isLeapYear(int year){
        if(year % 100==0){
            if(year%400==0) {
                return true;
            }
        }else{
            if(year%4==0){
                return true;
            }
        }
//其余情况都不是闰年，返回false
        return false;
    }
}

二.方法重载

2.1 定义：在同一个类中，定义了若干个①方法名称相同②参数的个数或者类型不同③与返回值无关的一组方法，称为方法重载。

public class MethodOverLoad {
    public static void main(String[] args) {
        System.out.println("The maximum of 3 and 4 is"  +  max(3,4));
        System.out.println("The maximum of 3.0 and 4.2 is"  +  max(3.0,4.2));
        System.out.println("The maximum of 3.1, 4.5, and 10.8 is"  +  max(3.1, 4.5, 10.8));
    }
    //定义一个方法，返回两个数整数中的最大值
    public static int max(int num1,int num2){
        if(num1>num2)
            return num1;
        else
            return num2;
    }
    //定义第二个方法，返回两个double中的最大值
    public static double max(double num1,double num2){
        if(num1>num2)
            return num1;
        else
            return num2;
    }
    //定义第三个方法，返回三个double中的最大值
    public static double max(double num1,double num2,double num3) {
            return max(max(num1,num2),num3);
    }

}

注意：方法重载与方法的返回值无关！！！看的都是参数类型或个数，若两个同名方法，参数列表完全一致，只是返回值不同，无法构成方法重载。

三.方法递归（程序结构）

3.1 定义：方法在执行过程中，自身调用自身的过程。

public static void print(){
system.out.println("1111")
print();//自己调用了自己
}//递归一定是自己调用自己，方法内部执行过程中调用自身函数才叫做递归

3.2什么场景下才会用到递归？

• 一个大问题可以拆分为若干个子问题的解 =>

• 拆分后的子问题和原问题除了数据规模不同之外，解决的思路完全相同

• 存在递归出口（问题的拆分是有限的，不可能一直拆分下去）-》拆分问题的终止条件

3.3 如何写出递归函数：一定要宏观抓住递归函数的语义（定义这个函数解决什么问题），在函数内部解决当前能干的事情，剩下的事情交给子函数也就是递归函数。

public class MethodRecursion {
    public static void main(String[] args) {
        System.out.println(factor(5));
        System.out.println(sum(3));
        System.out.println(fibo(4));
    }
    //1.求一个整数num的阶乘
    public static int factor(int num){
        if(num==1)
            return num;
        else{
            int result= num* factor(num-1);
            return result;
        }
    }
    //2.求1+2+3+4+...+n
    public static int sum(int n){
        if(n==1)
            return n;
        else{
            int result = n+ sum(n-1);
            return result;
        }
    }
    //斐波那契数列
    public static int fibo(int n){
        if(n==1||n==2){
            return 1;
        }else{
            return fibo(n-1)+fibo(n-2);
        }
    }
}