JavaSE语法（4）——详解解读Java中的方法与方法重载

目录

 

✏️方法概念及使用

1.什么是方法

2.方法的定义

3.方法调用的执行过程

4.实参和形参的关系

5.没有返回值的方法

✏️方法重载

1.引入

2.方法重载概念

3.方法签名

✏️递归

1.递归的概念

2.递归执行过程分析

---

前言：该篇里的“static、public”的用法会在后续更新，现将方法的格式就默认为“public static 类型 方法名 （）”。

✏️方法概念及使用

---

1.什么是方法

        方法就相当于C语言中的“函数”，用法大都是相同的。其意义：

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

---

2.方法的定义

格式：

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
    //方法体代码;
    return 返回值;//没有返回值就不写
}

(ps：修饰符就是 public、private……、static，这些后面会更新，可能有点久。)

例：检测一个年份是否为闰年、

    public class Product{
        /**
         * @param year 传入一个年数
         * @return 是闰年返回 true，否则返回false
         */
        public static boolean isLeapYear(int year){
            if((0 == year % 4 && 0 != year % 100) || 0 == year % 400){
                return true;
            }else{
                return false;
            }
        }
    }

例：实现一个两个整数相乘的方法

    public class Product{
        /**
         *
         * @param x 传入一个int型的数
         * @param y 传入一个int型的数
         * @return 返回 x 与 y 的乘积
         */
        public static int add(int x, int y) {
            return x * y;
        }
    }

注意：

• 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void。
• 方法名字：采用小驼峰命名，也就是第一个单词首字母小写，后继的单词首字母大写。
• 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开。
• 方法体：方法内部要执行的语句。
• 在java当中，方法必须写在类当中。
• 在java当中，方法不能嵌套定义。
• 在java当中，没有方法声明一说。

---

3.方法调用的执行过程

过程：

        调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到调方法继续往下执行。

 注意：Java中方法的定义位置没有严格要求，定义在main方法后也行，且没有像C语言中的“函数声明”这种东西。

例：计算两个整数相加。

public class Method {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("第一次调用方法之前");
        int ret = add(a, b);
        System.out.println("第一次调用方法之后");
        System.out.println("ret = " + ret);
        System.out.println("第二次调用方法之前");
        ret = add(30, 50);
        System.out.println("第二次调用方法之后");
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        System.out.println("调用方法中 x = " + x + " y = " + y);
        return x + y;
    }
}

        结果：

第一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

---

4.实参和形参的关系

        方法的形参相当于数学函数中的自变量，比如：1 + 2 + 3 + … + n的公式为sum(n) =n*（a1+an）/ 2

        Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。

    public static int getSum(int N){ // N是形参
        return (1+N)*N / 2;
    }

    public static void main(String[] args) {
        int a = getSum(10); // 10是实参,在方法调用时，形参N用来保存10
        int b = getSum(100); // 100是实参，在方法调用时，形参N用来保存100        
    }

 注意：在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体。

例: 交换两个整型变量

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

结果：

swap: x = 20 y = 10
main: a = 10 b = 20

        可以看到，在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中没有指针，所以得用引用类型来解决这类问题。（ps：详细的在下一篇文章（与数组的内容一起）。后面再补）

public class TestMethod {
    public static void main(String[] args) {
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
    }
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
} 

结果：

// 运行结果
arr[0] = 20 arr[1] = 10

---

5.没有返回值的方法

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

例：

class Test {
    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);
    }
}

---

---

✏️方法重载

---

1.引入

        我想要分别对（int a    int  b）与（double c   double  d）求和：

class TestMethod {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int add(int x, int y) {
        return x + y;
    }
}

结果：

// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);

        结果显然是错的，因为add的形参是int类型，不能传double类型。如何解决问题呢？可以重新写一个double类型的addDouble()方法，但是还有其它办法吗？如下。

---

2.方法重载概念

        上面的问题可以用重载解决，什么是重载？

        重载相当于一词多义，比如：扶老奶奶过马路的人叫好人；跟女神表白时，女神说：“你是个好人”。这两个“好人”就有多重意义。

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

        回到上一个add的问题，我们可以写一个add的重载：

class TestMethod2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);

        int a3 = 10;
        int b3 = 20;
        int c3 = 30;
        int ret3 = add(a3,b3,c3);
        System.out.println("ret3 = " + ret3);

        double a4 = 10.5;
        double b4 = 20.5;
        double c4 = 30.5;
        double ret4 = add(a4,b4,c4);
        System.out.println("ret4 = " + ret4);
    }
    public static int add(int x, int y) {
        return x + y;
    }

    public static double add(double x, double y) {
        return x + y;
    }

    public static int add(int x, int y,int z){
        return x + y + z;
    }
    public static double add(double x, double y,double z){
        return x + y + z;
    }
}

结果：

ret = 30
ret2 = 31.0
ret3 = 60
ret4 = 61.5

注意：

• 方法名必须相同
• 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序(不是形参变量的次序)必须不同)
• 与返回值类型是否相同无关
• 两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的。

例：

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

结果：

        // 编译出错
        Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
                ^
        1 个错误

        编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法，如果两个方法仅仅只是因为返回值类型不同，那么编译器就推不出来。

---

3.方法签名

        在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的

变量，那为什么类中就可以定义方法名相同的方法呢？

        方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数

列表+返回值类型，构成方法完整的名字。

        例：

public class TestMethod {
    public static int add(int x, int y){
        return x + y;
    }
    public static double add(double x, double y){
        return x + y;
    }
    public static void main(String[] args) {
        add(1,2);
        add(1.5, 2.5);
    }
}

        上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：

• 找到该类所在项目的文件位置，找到 out

•  一直点，直到看到.class文件

•  在上面写cmd进入命令行窗口

 

•  输入：javap -v 字节码文件名字   (回车)即可

 可以看到：

         其中的D表示double类型，I表示int类型，add真正的名字会被类型决定。

---

---

✏️递归

---

1.递归的概念

        一个方法在执行过程中调用自身, 就称为 "递归"。

递归的必要条件：

• 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
• 递归出口

例: 递归求 N 的阶乘

public class TestMethod {
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
        if (n == 1) {
            return 1;
        }
        return n * factor(n - 1); // factor 调用函数自身
    }
}

结果：

ret = 120

---

2.递归执行过程分析

例：递归求 N 的阶乘

public class TestMethod {
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
        System.out.println("函数开始, n = " + n);
        if (n == 1) {
            System.out.println("函数结束, n = 1 ret = 1");
            return 1;
        } 
        int ret = n * factor(n - 1);
        System.out.println("函数结束, n = " + n + " ret = " + ret);
        return ret;
    }
}

结果：

函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

 过程：