方法的使用

方法就是一个代码片段. 类似于 C 语言中的 "函数"。方法存在的意义(不要背, 重在体会): 1. 是能够模块化的组织代码(当代码规模比较复杂的时候). 2. 做到代码被重复使用, 一份代码可以在多个位置使用. 3. 让代码更好理解更简单. 4. 直接调用现有方法开发, 不必重复造轮子。

比如：现在要开发一款日历，在日历中经常要判断一个年份是否为闰年，则有如下代码：

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        if(((year % 4 == 0)&&(year % 100 != 0))||(year % 400 == 0)){
            System.out.println(year+"是闰年");
        }else {
            System.out.println(year+"不是闰年");
        }
    }
}

但是当我们要重复使用的时候，我们就得重新写一份这样的代码，我们就会觉得很不方便，因此就有了方法。把判断是否为闰年的代码分装成一个方法。

方法定义 

方法语法格式：

修饰符 返回值类型 方法名称([参数类型 形参 ...]){
    方法体代码;
    [return 返回值];
}

现在我们现阶段用的修饰符都是public static  ，等我们学习到后面的时候，就会在来学习这个。

返回值类型就是根据我们自己的需要来给。

方法名称虽然可以随意给，但是我们默认都是要能够表达这个方法的用法。例如：我们要创建一个有整数加法功能的方法，虽然这个方法名，可以是a，b……但是我们默认都是写成sumInt。 

练习：实现一个方法，检测一个年份是否为闰年。

public class Test {
     public static void isLeapYear(int year) {
        if(((year % 4 == 0)&&(year % 100 != 0))||(year % 400 == 0)){
            System.out.println(year+"是闰年");
        }else {
            System.out.println(year+"不是闰年");
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        //当然也可以根据返回值来判断是否为闰年,这也就说明实现同一个功能的方法有多种
        isLeap(year);
    }
}

练习：实现一个两个整数相加的方法。 

public class Test {
    public static int sumInt(int x, int y){
        return x+y;//也可以在这里直接算出和再打印出来
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int ret = sumInt(a,b);
        System.out.println(a+"+"+b+"的和："+ret);
    }
}

参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开。在Java当中，方法必须写在类当中。方法不能嵌套定义。在java当中，没有方法声明一说。

实参和形参的关系

和C语言一样，形参是实参的一份临时拷贝。

例子：交换两个整型变量。

public class Test {
    public static void swap(int a, int b){
        int tmp = a;
        a = b;
        b = tmp;
    }
    public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         int a = scanner.nextInt();
         int b = scanner.nextInt();
         System.out.println("交换前："+a+" "+b);
         swap(a,b);
         System.out.println("交换后："+a+" "+b);
    }
}

可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，即没有交换成功。 

实参a和b是main方法中的两个变量，其空间在main方法的栈(一块特殊的内存空间)中，而形参x和y是swap方法中的两个变量，x和y的空间在swap方法运行时的栈中，因此：实参a和b 与形参x和y是两个没有任何关联性的变量， 在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b 产生任何影响。 注意：对于基础类型来说, 形参相当于实参的拷贝。即传值调用。 那就有小伙伴提出了用指针的方式来解决，但可惜的是Java中不能拿到局部变量的地址。

【解决办法】: 传引用类型参数 (例如数组来解决这个问题）

这个我们在后面学习数组的时候再来详细学习。

方法重载

概念：在日常生活中，一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。 在Java中方法也是可以重载的。如果多个方法的名字相同，参数列表不同，则称该种方法被重载了。

那为什么要重载呢？我们先来看一个代码：

public class Test {
    public static int add(int x,int y){
        return x+y;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int ret = add(a,b);
        System.out.println(a+"+"+b+"的和:"+ret);

        float a1 = scanner.nextFloat();
        float b1 = scanner.nextFloat();
        int ret2 = add(a1, b1);//编译器会报错
        System.out.println(a1+"+"+b1+"的和:"+ret2);
    }
}

编译器之所以会报错，是因为add的参数是int类型，而我们传过去的参数是float的类型。那要计算float类型数据的和，就得写一个方法来计算float类型的和，另外再取一个方法名。如果是在一个大型的项目里，我们会发现太多的方法名，记不住。这时就提出了一个概念叫方法重载。我们把方法名取一样的，用参数类型来区别两个方法。就好比现在不管是float类型的加法，还是int类型的加法，都去add这个方法名，参数取不一样的就行了。

方法重载要注意的是： 1. 方法名必须相同 2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同) 3. 与返回值类型是否相同无关。

现在我们就根据方法重载来重新写这个求和的代码

public class Test {
    public static float add(float x, float y){
        return x+y;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int ret = add(a,b);
        System.out.println(a+"+"+b+"的和:"+ret);
        /*float a1 = scanner.nextFloat();
        float b1 = scanner.nextFloat();
        int ret2 = add(a1, b1);*/

        float a1 = scanner.nextFloat();
        float b1 = scanner.nextFloat();
        float ret1 = add(a1, b1);
        System.out.println(a1+"+"+b1+"的和："+ret1);
    }
}

方法签名 

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？其实是因为有一个方法签名。方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

递归

一个方法在执行过程中调用自身, 就称为递归。递归是把一个问题简化为一个与原问题相似但规模较小的问题。

递归有两个特点：1. 递归存在一个限制条件，当满足这个限制条件的时候，递归就会停止，不再继续。；2. 每一次递归之后，就会越来越接近这个限制条件。

具体的可以去看下面这篇博客：函数递归知识点与经典例题-CSDN博客

下面我们就通过一些练习题来体验递归的思想。 

练习1：递归求 N 的阶乘。

public class Test {
    public static int fact(int n){
        if(n == 1){
            return 1;
        }
        return n*fact(n-1);
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        //例如:5!=5*4!=5*4*3!=……=5*4*3*2*1!=5*4*3*2*1
        int ret = fact(n);
        System.out.println(n+"的阶乘为："+ret);
    }
}

我们是把5！转换为5*4！。这个就把问题简化了，这个限制条件是n为1。

练习2：按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) 。

4是最容易拿到的，%10就可以了，要顺序打印每一位的话，就得先拿到1，那么我们就得不断的/10，%10，知道拿到1，我们就可以停止递归了。

public class Test {
    public static void print(int n){
        if(n < 10){
            System.out.print(n+" ");
            return ;
        }
        print(n/10);
        System.out.print(n%10+" ");
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        //例如:5!=5*4!=5*4*3!=……=5*4*3*2*1!=5*4*3*2*1
        print(n);
    }
}

练习3：递归求 1 + 2 + 3 + ... + 10 .

这个问题可以简化为（1+2+……+9）+10，就可以简化为到1.

public class Test {
    public static int sum(int n){
        if(n==0){
            return 0;
        }else {
            return n + sum(n-1);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = sum(n);
        System.out.println(ret);
    }
)

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

这个和顺序打印每一位是差不多的。

public class Test {
    public static int print(int n){
        if(n<10){
            return n;
        }else {
            return n%10 + print(n/10);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = print(n);
        System.out.println(ret);
    }
}

练习5：求斐波那契数列的第 N 项 

斐波那契数列，大概分为两种：一部分认为第一个和第二个斐波那契数都是1。

但是又有一部分认为是上面这个。

我们以第一个和第二个斐波那契数为1，这个为例子。 

public class Test {
    public static int fib(int n){
        if(n == 1){
            return 1;
        } else if (n == 2) {
            return 1;
        }else {
            return fib(n-1) + fib(n-2);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fib(n);
        System.out.println(ret);
    }
}

当我们要求第40个斐波那契数的时候，单独看第三个斐波那契数被计算了几次。

public class Test {
    public static int count = 0;//这个是类的成员变量. 后面会详细介绍到.
    public static int fib(int n){
        if(n == 3){
            count++;
        }
        if(n == 1){
            return 1;
        } else if (n == 2) {
            return 1;
        }else {
            return fib(n-1) + fib(n-2);
        }
    }
    public static void main(String[] args) {
        // 求斐波那契数列的第 N 项
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fib(n);
        System.out.println(ret);
        System.out.println("第三个斐波那契数被重复计算的次数："+count);
    }
}

我们发现光是第三个斐波那契数就被计算了三千多万次。可想而知递归求斐波那契数的效率有多低。 

我们就可以换成迭代的方法来求。（循环）

public class Test {
    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;
        }
        int a = 1;
        int b = 1;
        int c = 0;
        for (int i = 3; i <= n; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fib(n);
        System.out.println(ret);
    }
}