Java基础：方法（函数）的完全解析——定义、传参、重载与递归

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

在Java编程中，方法的概念与C语言中的函数类似，是用于封装一系列执行逻辑的代码块，通常用来完成特定功能或解决某个具体问题。

方法的结构定义
一个完整的方法由以下几个部分构成：修饰符、返回值类型、方法名称、参数列表（也称为形式参数）以及方法体。其基本语法格式如下：

修饰符 返回值类型 方法名(形参类型 形式参数) {
    方法体
}

例如，定义一个名为addTwoNum的方法，用于实现两个整数相加：

public static int addTwoNum(int num1, int num2) {
    return num1 + num2;
}

• 修饰符：如public、static等，属于可选项，主要用于控制方法的访问权限和调用方式。
• 返回值类型：表示方法执行完毕后返回的数据类型，如int。若无返回值，则使用void关键字。
• 方法名：遵循标识符命名规范，建议语义清晰，采用小驼峰命名法，例如addTwoNum。
• 方法参数：又称形参，包含参数的数据类型和名称。参数列表可以为空，即方法可以不接收任何输入。
• 方法体：包含实际执行的代码逻辑。如果方法有返回值，则必须包含return语句。

方法的调用方式
在Java中，静态方法可通过“类名.方法名”进行调用，实例方法则通过“对象.方法名”来调用。若在同一类的静态方法中调用另一个静态方法，类名可省略。

示例代码如下：

public class Demo4 {
    public static void main(String[] args) {
        int sum = addTwoNum(1, 2);
        System.out.println(sum);
    }

    public static int addTwoNum(int num1, int num2) {
        return num1 + num2;
    }
}

方法的调用可能表现为赋值操作（当方法具有返回值时），也可能仅作为一条独立语句执行（如没有返回值的情况）：

int sum = addTwoNum(1, 2);  // 将方法返回结果赋值给变量
System.out.println(sum);    // 直接调用方法，作为一条语句执行

形参与实参的区别
- 形参：指在方法声明时括号内定义的参数，即形式上的参数，仅在方法内部有效。例如，在以下方法中，num1和num2就是形参：

public static int addTwoNum(int num1, int num2) {  // num1、num2为形参
    return num1 + num2;
}

- 实参：指在调用方法时传入的具体数值或变量，即实际传递的参数。实参会将其值传递给对应的形参，这一过程基于值传递机制。例如：

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    int sum = addTwoNum(a, b);  // a、b为实参
    System.out.println(sum);
}

在此过程中，实参变量所存储的数据会被复制并传递给形参，因此形参获得的是实参的一个副本。

Java中的参数传递机制：按值传递
Java中所有的参数传递都采用“按值传递”的方式。这意味着在方法调用时，系统会将实参的值复制一份传给形参。由于基本数据类型和引用数据类型在内存中存储的内容不同，导致传递后的效果有所差异。

基本数据类型的参数传递
对于基本数据类型（如byte、short、int、long、float、double、char等），传递的是变量本身的值。因此，对形参的修改不会影响原始变量。

示例代码如下：

public class Demo5 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("方法调用前 a： " + a + " b： " + b);
        change(a, b);
        System.out.println("方法调用后 a： " + a + " b： " + b);
    }

    public static void change(int m, int n) {
        m = 30;
        n = 40;
    }
}

输出结果为：
方法调用前 a： 10 b： 20
方法调用后 a： 10 b： 20

可见，尽管在change方法中修改了形参的值，但原始变量a和b并未受到影响。

引用数据类型的参数传递
当参数为引用数据类型（如数组、对象等）时，实参传递的是该引用的地址副本。虽然地址本身是按值传递的，但由于形参与实参指向同一块堆内存区域，因此通过形参修改对象内容会影响原始对象。

这种情况下，虽然引用变量本身不能被重新赋值以改变外部对象的指向（因为是值传递），但可以通过该引用来修改其所指向对象的状态，从而产生“修改原变量”的效果。

在Java中，当传递引用数据类型给方法时，形参接收到的是实参对象的内存地址。由于地址被复制，实参与形参指向同一块堆内存中的数据，因此在方法内部对形参所引用的对象进行修改，会直接影响到原始变量的数据状态。

例如以下代码演示了数组作为参数传递时的行为：

public class Demo6 {
    public static void main(String[] args) {
        int[] a = {10, 20, 30};
        System.out.println("方法调用前 a[0]： " + a[0] + " a[1]： " + a[1] + " a[2]： " + a[2]);
        change(a);
        System.out.println("方法调用后 a[0]： " + a[0] + " a[1]： " + a[1] + " a[2]： " + a[2]);
    }

    public static void change(int[] m) {
        m[0] = 100;
        m[1] = 200;
        m[2] = 300;
    }
}
    

输出结果为：

方法调用前 a[0]： 10 a[1]： 20 a[2]： 30

方法调用后 a[0]： 100 a[1]： 200 a[2]： 300

进程已结束，退出代码为 0

上述示例中，数组a通过引用传入change方法，m与a共享相同的内存地址，因此对m元素的修改等同于直接修改a中的元素。

关于方法重载（Overloading）

Java支持方法重载机制，即允许在一个类中定义多个同名但参数列表不同的方法。这里的“参数列表不同”指的是参数的数量、类型或顺序有所差异。编译器会根据调用时传入的实际参数来决定具体执行哪一个方法版本。

例如，可以同时存在两个名为add的方法，分别用于处理整型和双精度浮点数的加法操作：

public class Demo7 {
    public static void main(String[] args) {
        int a = add(10, 20);
        double b = add(10.0, 20.0);
    }

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

    public static double add(double a, double b) {
        return a + b;
    }
}
    

需要注意的是，仅靠返回值类型的不同无法构成有效的方法重载。也就是说，如果两个方法名称相同、参数列表完全一致，即使返回类型不同，也会导致编译错误。

可变参数（Varargs）的使用

为了应对参数数量不确定的场景，Java提供了可变参数功能。在声明方法时，可以在某个参数类型后加上“...”符号，表示该参数可接收零个或多个对应类型的值。这些值在方法体内将以数组形式存在，可以直接遍历或访问。

以下是一个计算任意个整数之和的例子：

public class Demo8 {
    public static void main(String[] args) {
        int result = add(1, 2, 3, 4, 5);
        System.out.println(result);
    }

    public static int add(int... nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }
}
    

关键规则包括：一个方法只能有一个可变参数，并且它必须位于参数列表的最后位置。例如：

public static int addTo(int a, int... b) {}

递归方法简介

递归是指方法在其定义内部调用自身的一种编程技术。它常用于解决具有自相似结构的问题，如阶乘、斐波那契数列、树形遍历等。在递归过程中，每次调用都会将问题分解为更小的子问题，直到达到基础条件（终止条件）为止。

虽然本文未展示具体递归代码，但需注意递归必须设置明确的出口条件，否则会导致无限调用，最终引发栈溢出异常（StackOverflowError）。

方法之间的相互调用是程序逻辑组织的重要方式。例如main方法可以调用自定义的add方法，也可以调用系统提供的println等工具方法，从而实现复杂的功能组合。

public class Demo8 {
    public static void main(String[] args) {
        int result = add(1, 2, 3, 4, 5); // 调用自定义的add方法
        System.out.println(result); // 输出结果，使用Java内置的println方法
    }

    public static int add(int... nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }
}

与 Python 等高级编程语言类似，Java 同样支持递归机制。 递归指的是在方法定义的过程中，直接或间接地调用该方法自身的一种编程方式。 典型的递归方法通常包含两个关键部分： 一是存在某个条件判断，使得方法能够再次调用自身，形成递归调用链； 二是在特定情况下满足终止条件，此时不再进行自我调用，而是返回一个明确的基础解，防止无限递归。 例如，以下代码展示了一个通过递归实现求解从 1 到 n 所有整数之和的方法：

// 使用递归计算 1 到 n 的累加和
public static int sum(int n) {
    if (n == 1) { // 基础情况：递归终止条件
        return 1;
    } else {
        return n + sum(n - 1); // 递归调用，逐步向基础情况靠近
    }
}

值得注意的是，大多数可以通过递归解决的问题，也可以采用循环结构来实现相同的功能。 开发者可根据具体场景、代码可读性以及性能需求，选择使用递归或循环的方式来编写程序逻辑。

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：java基础 Java jav overload OverFlow

相关内容：Java方法重载