【0基础学Java第五课】-- 方法的使用

5.1 什么是方法

方法就是一个代码片段. 类似于 C 语言中的 “函数”。方法存在的意义(不要背, 重在体会):

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.

5.2 方法定义

修饰符 返回值类型 方法名称([参数类型 形参 …]){
方法体代码;
[return 返回值];
}
例如：方法实现闰年

    public static boolean isLeapYear(int year){
        if((0 == year % 4 && 0 != year % 100) || 0 == year % 400){
            return true;
        }else{
            return false;
        }
    }

注意：

1. 修饰符：现阶段直接使用public static 固定搭配
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
   void
3. 方法名字：采用小驼峰命名
4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
5. 方法体：方法内部要执行的语句
6. 在java当中，方法必须写在类当中
7. 在java当中，方法不能嵌套定义
8. 在java当中，没有方法声明一说

5.3方法调用的执行过程

【方法调用过程】
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行

方法栈帧

例题：求n的阶乘和

public class Method{

    public static int fac(int n) {
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret *= i;
        }
        return ret;
    }

    public static int facSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        return sum;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("n的阶乘和");
        int num = scanner.nextInt();
        System.out.println(facSum(num));
    }

使用方法，避免使用二重循环，让代码更简单清晰。

5.4 实参和形参的关系（重点）

Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
如下图：形参的改变不会影响实参，结果打印的x是10，y还是20。

5.5 没有返回值的方法

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void。

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        print(a, b);
    }
    public static void print(int x, int y) {
        System.out.println("x = " + x + " y = " + y);
    }

5.6 方法重载

public class Method {
    public static int add(int a,int b) {
        return a+b;
    }
    public static int add(int a,int b,int c) {
        return a+b+c;
    }
    public static double add(double c,double d) {
        return c+d;
    }

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int ret = add(x,y);
        System.out.println(ret);

        double d1 = 10.5;
        double d2 = 12.5;
        double dd = add(d1,d2);
        System.out.println(dd);
    }

注意：

1. 方法名必须一样
2. 参数列表必须不同（个数，数据类型，顺序）
3. 返回值是否一样，不影响方法重载

5.7 方法签名

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

5.8 递归

递 和 归都属于动词
理解 递的过程 和 归的过程 —> 什么时候 递结束/开始条件
如果没有开始结束条件，就会报错 栈溢出错误。如下图：
递 和 归的过程：

例题：递归求n的阶乘

    public static void main(String[] args) {
        int ret = fac(3);
        System.out.println(ret);
    }

    public static int fac(int n) {
        if (n == 1) {
            return 1;
        }
        return n * fac(n-1);
    }

解析：

5.9 递归练习

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

    public static void main(String[] args) {
            print(1234);
    }

    public static void print(int n) {
        if (n < 10) {
            System.out.print(n);
            return;
        }
        print(n/10);
        System.out.print(" "+n % 10);
    }

解析：

递归求 1 + 2 + 3 + … + 10

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

写一个递归方法，输入一个非负整数，返回组成它的数字之和.

例如，输入 1729, 则应该返回1+7+2+9，它的和是19

    public static void main(String[] args) {
        System.out.println(sumEvery(1927));
    }

    public static int sumEvery(int n) {
        if (n < 10) {
            return n;
        }
        return n%10 + sumEvery(n/10);
    }

斐波那契数列的第N项

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你计算到第几项：");
        int num = scanner.nextInt();
        System.out.println(fib(num));
    }
    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) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你计算到第几项：");
        int num = scanner.nextInt();
        System.out.println(fib2(num));
    }
    public static int fib2(int n) {
        int last2 = 1;
        int last1 = 1;
        int sum = 0;
        for (int i = 3; i <= n; i++) {
            sum = last1 + last2;
            last2 = last1;
            last1 = sum;
        }
        return sum;
    }

汉罗塔递归

    //pos1 起始位置
    //pos2 中转位置
    //pos3 目标位置
    public static void main(String[] args) {
        hanoi(3,'A','B','C');
    }
    public static void hanoi(int n,char pos1,char pos2,char pos3) {
        if (n == 1) {
            move(pos1,pos3);
            return;
        }
        hanoi(n-1,pos1,pos3,pos2);
        move(pos1,pos3);
        hanoi(n-1,pos2,pos1,pos3);
    }
    public static void move(char pos1,char pos2) {
        System.out.print(pos1 + "-> " + pos2 + " ");
    }