Java中方法的使用

方法的概念及使用

什么是方法

方法是一个 代码片段。类似于C语言中的“函数”。方法存在的意义：

1. 是能够模块化的组织代码（当代码规模比较复杂的时候）；
2. 能够重复使用，一份代码可以在多个位置使用；
3. 让代码更好理解更加简单；
4. 直接调用现有方法，不必重复部分过程。

方法定义

方法语法格式

//方法定义
修饰词 返回类型 方法名称( 参数类型 形参) {
方法体
return 返回值；

示例

一
实现一个函数，检测某一年是否为闰年

//方法的使用相关内容，主要是对知识的介绍。


public class Test {
    //实现一个函数，检测一个年份是否为闰年
    public static boolean judgeLeapYear (int year) {
        if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        int year = 2022;
        System.out.println(judgeLeapYear(year));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

二
用方法实现两个整数相加。

public class Test {

    public static int sum(int a, int b) {
        return a + b;
    }

    //用方法实现两个整数相加。
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        System.out.println(sum(a, b));
        scan.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

【注意事项】：

• 修饰符：现阶段我们直接使用public static 固定搭配；
• 返回值类型：如果有返回值，返回值类型必须要与返回的实体类型一致；如果没有返回值，写成void即可；
• 方法名：采取小驼峰的形式（首字母小写，其他单词首字母大写）；
• 参数列表：如果方法不需要参数，（）什么都不写或者void；如果有参数，需指定参数类型，多个参数之间用逗号隔开；
• 在Java中，方法必须写在类当中；
• 在Java中，方法不能相互嵌套定义；
• 在Java中，方法不用声明。

方法调用的执行过程

【方法调用过程】
调用方法 —> 传递参数 —> 找到方法地址 —> 执行方法体 —> 被调方法结束返回 —> 回到主调方法
【注意事项】

• 定义方法的时候，不会执行方法的代码，只有调用的时候才会执行。
• 一个方法可以多次被调用。

示例

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(sum(a, b));
        a = 30;
        b = 40;
        System.out.println(sum(a, b));
        a = 19;
        b = 1020685;
        System.out.println(sum(a, b));
        System.out.println(judgeLeapYear(30222));
        System.out.println(judgeLeapYear(20333));
        System.out.println(judgeLeapYear(30258));
    }
    public static int sum(int a, int b) {
        return a + b;
    }
     public static boolean judgeLeapYear (int year) {
        if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
            return true;
        }
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在这里我们频发的调用方法，但是我们不必重复写相同的判断过程，这就是方法带给我们的好处。

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

***Java中方法的形参就相当于上面书写sum函数的自变量 a 和 b，用来接收 sum 函数在调用时传递的值。***形参的名字（a, b）可以随便改，对方法没有影响。形参只是方法在定义时需要借助的一个变量，用来保存调用方法时，所传过来的值。

//形参和实参的认识
    public static int sum1(int a, int b, int c) { //a, b, c 是形参
        return a + b + c;
    }

    public static void main(String[] args) {
        sum1(10,20,30);//10 20 30 在这里为实参
    }
1
2
3
4
5
6
7
8

在这里要注意，形参是实参的临时拷贝，形参和实参是两个互不影响的两个实体
【实例】
我们用方法交换两个整数的值。

public class Test {

    //对实参和形参认识的深入理解
    public static void swap(int a, int b) {
        int tmp = 0;
        tmp = a;
        a = b;
        b = tmp;
    }

    public static void main(String[] args) {
        int a = 152;
        int b = 206;
        swap(a, b);
        System.out.println(a + " " + b);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里我可以自己运行一下发现，形参 a b 的值发生了改变，但是实参 a b 的并没有发生改变。
【原因分析】
实参 a 和 b 是在 main 方法中的两个变量，其空间在 main 方法的栈中，而形参 a 和 b 是在 swap 方法的两个变量，其空间是在 swap 方法运行时的栈中。这种调用，不能改变实参的值，所以被我们叫做传值调用。

没有返回值的方法

方法的放回值是可以选择的。有时候没有返回值也是可以的，没有时返回值必须写成 void

public class Test {


    //返回值为空的情况
    public static void print(int a, int b) {
        System.out.println(a + " + " + b + " = " + (a + b));
    }

    public static void main(String[] args) {
        int a = 22;
        int b = 89;
        print(a, b);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这里我们计算两个数的和，并直接打印，我们并不需要返回值。

方法的重载

为什么需要方法的重载

在一些情况下，我们需要把方法命名，但是我们发现根据含义起名字，可能会导致方法名的重复，这就需要我们跟换其他名字，但是方法的重载将避免这种情况的发生。

方法重载的概念

在Java中，如果多个方法名字相同，但是参数列表不同，则称该方法被重载。

public class Test {

    //方法的重载
    public static int sum(int a, int b) {
        return a + b;
    }
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }

    public static void main(String[] args) {
        int a = 50;
        int b = 90;
        int c = 77;
        int d = 86;
        System.out.println(sum(a, b));
        System.out.println(sum(a, b, c));
        System.out.println(sum(a, b, c, d));
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

注意：

• 方法名相同；
• 参数列表不同（参数的个数、类型、次序不同）；
• 与返回值类型是否相同无关。

方法签名

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

public class Test {

    //方法的重载
    public static int sum(int a, int b) {
        return a + b;
    }
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }

    public static void main(String[] args) {
        int a = 50;
        int b = 90;
        int c = 77;
        int d = 86;
        System.out.println(sum(a, b));
        System.out.println(sum(a, b, c));
        System.out.println(sum(a, b, c, d));
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在此代码中，int sum(int,int), int sum(int ,int, int), int sum(int, int, int, int) 是这四个方法的真正名字。

递归

递归在生活中的应用

从前有座山，山里有座庙，庙里有个老和尚，给小和尚讲故事，讲的就是：
从前有座山，山里有座庙，庙里有个老和尚，给小和尚讲故事，讲的就是：
从前有座山，山里有座庙，庙里有个老和尚，给小和尚讲故事，讲的就是：
…

同样还有尔罗斯套娃，他们有着共同的特点就是：自身中又包含这自身。这种思想在数学和编程中非常有用，因为有时候，我们遇到的问题不能直接很好的解决，但是我们发现将原问题拆解成其子问题之后，子问题与原问题有着相同的解法，子问题解决了，原问题也迎刃而解。

递归的概念

一个方法在执行过程中调用自身。
【必要条件】

• 原问题划分成其子问题，注意：子问题与原问题有着相同的解法。（难点与重点）
• 有结束条件。在递归的过程中必须逐步逼近正确答案，且有结束的条件，使其不再递归。

示例

递归求N的阶乘

public class Test {

    //递归
    public static int factorial(int n) {
        if(n == 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int n = 4;
        System.out.println(factorial(n));

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

递归练习

汉诺塔问题：有三根柱子A、B、C，A上有64个圆盘，最下面的圆盘最大，向上依次减小，要求把圆盘从 A 转移到 C 上，且移动过程中小的圆盘不能放在大的圆盘下面。


此类问题的核心是：

• 我们先将最大的圆盘以上的所有圆盘从 A 借助 C 移动到 B 上；
• 再将最大的圆盘从 A 移动到 C；
• 再将剩下的最大的圆盘以上所有圆盘从 B 借助 C 移动到 A 上；
• 再将 B 上剩下的一个圆盘从 B 移动到 C上；
• 循环往复 （我们发现这时我们又回到了原来的问题上，C 上又两个最大的圆盘，其他的圆盘都在A上）。
• 结束条件：我们发现

import java.util.Scanner;

public class Test {

    //汉诺塔问题
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n= scan.nextInt();
        hanoi( n,'A','B','C');
    }
    public static void hanoi(int n, char  A,char B,char C){
        if (n==1){
            move(n,A,C);
            return;
        }
        hanoi(n-1,A,C,B);
        move(n,A,C);
        hanoi(n-1,B,A,C);
    }
    private static void move(int n,char sourceTower,char destTower) {
        System.out.println("圆盘 "+ n + "正在从" + sourceTower +" 移动到 "+ destTower);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这里我们要注意ABC并不是固定，我们可以理解为A（第二个参数）为放盘子的柱子，B（第三个参数）为中间的柱子，C（第四个参数）为目标柱子。