首页课程创意工坊价格

5 / 10

Java类和对象

Java方法(函数) | 自在学

Java方法(函数)

在之前的编程学习中，我们编写的程序都是将所有代码放在main方法中。虽然这样也能完成程序的功能，但当程序变得复杂时，所有的代码都混在一起，不仅难以理解，而且难以维护。

如果我们要建造一座房子，不可能把所有的材料都堆在一起。我们需要将房子分成不同的部分：地基、墙壁、屋顶、门窗等。每个部分都有特定的功能和结构。编程也是如此，我们需要将复杂的程序分解成小的、可管理的模块。

在Java中，这些模块称为方法。方法就像程序中的“小工具”，每个方法都有特定的功能，可以独立完成某个任务。

Java方法(函数)

方法的基本概念

方法是由一组完成特定功能的语句组成的代码块。它可以接收外部传入的数据（称为参数），在方法内部对这些数据进行处理，执行一系列操作。

方法执行完毕后，可以选择将处理结果返回给调用者（通过返回值），也可以什么都不返回。我们可以把方法想象成一个“黑盒子”：你把需要处理的数据（参数）交给它，它在内部按照既定的步骤处理这些数据，然后把结果（如果有的话）返回出来。

这样做的好处是，方法内部的实现细节对外部是隐藏的，外部只需要知道如何使用这个方法，而不需要关心它是如何实现的。

方法的分类

Java中的方法可以分为两大类：

无返回值方法（void方法）：只执行任务，不返回任何值。就像你让某人去倒垃圾，他完成了任务，但没有带回任何东西。

有返回值方法：执行任务后，还会返回一个值。就像你让某人去买东西，他不仅完成了购买任务，还会把买到的商品带回来。

方法的组成部分

每个方法都有两个主要部分：

方法头：包含方法的修饰符、返回类型、方法名和参数列表
方法体：包含方法要执行的具体代码

让我们看一个简单的例子：

|
public class MethodDemo {
    public static void main(String[] args) {
        System.out.println("程序开始");
        
        // 调用无返回值方法
        displayMessage();
        
        // 调用有返回值方法
        int result = addNumbers(5, 3);
        System.out.println("5 + 3 = " + result);
        
        System.out.println("程序结束");
    }
    
    // 无返回值方法
    public static void displayMessage() {
        System.out.println("这是一个无返回值方法");
        System.out.println("它只执行任务，不返回任何值");
    }
    
    // 有返回值方法
    public static int addNumbers(int a, int b) {
        int sum = a + b;
        return sum;
    }
}

运行这个程序会输出：

|
程序开始
这是一个无返回值方法
它只执行任务，不返回任何值
5 + 3 = 8
程序结束

无返回值方法

无返回值方法的概念

无返回值方法（void方法）就像是一位“工人”，你可以让他去完成某项任务，但他完成后不会给你带回任何结果（即没有返回值）。这类方法的主要作用是执行某些操作，而不是计算并返回一个值。常见的无返回值方法用途包括：

显示信息：比如在控制台输出提示、打印欢迎语等。
打印数据：将变量、数组、表格等内容输出到屏幕上。
修改文件：执行写入文件、删除文件等操作，但不需要返回结果。
更新界面：在图形界面程序中，刷新界面、显示弹窗等。
执行一系列动作：比如初始化设置、清空数据、重置状态等。

无返回值方法通常用void关键字声明，表示该方法不返回任何数据。当你调用这种方法时，只会执行方法体中的代码，不会有任何值返回给调用者。即使方法内部有计算或处理，也不会通过return语句将结果带回主程序（但可以用return;单独结束方法的执行）。

举例来说，System.out.println()就是一个典型的无返回值方法：它负责把内容打印到控制台，但不会返回任何数据给你。

定义无返回值方法

无返回值方法的语法如下：

|
public static void 方法名() {
    // 方法体 - 要执行的代码
}

第一个无返回值方法示例

让我们创建一个简单的无返回值方法：

|
public class VoidMethodDemo {
    public static void main(String[] args) {
        System.out.println("主方法开始");
        
        // 调用无返回值方法
        showGreeting();
        showCurrentTime();
        
        System.out.println("主方法结束");
    }
    
    // 显示问候语的方法
    public static void showGreeting

运行这个程序会输出：

|
主方法开始
你好！欢迎学习Java方法！
今天是个好日子！
当前时间是：14:30:25.123
主方法结束

方法的调用过程

让我们详细分析一下方法是如何被调用的：

程序开始：从main方法开始执行
方法调用：遇到方法调用语句时，程序跳转到该方法
执行方法体：执行方法中的代码
返回调用点：方法执行完毕后，返回到调用它的地方继续执行

在控制结构中使用方法

方法调用不仅可以在主方法中直接使用，还可以灵活地嵌入到各种控制结构中，例如循环（如for、while）、条件语句（如if-else、switch）等。通过在这些结构中调用方法，可以让程序结构更加清晰、代码更加复用。例如，我们可以在循环中多次调用同一个方法，或者在不同的条件下调用不同的方法，从而实现更复杂的逻辑。

|
public class MethodInControlStructures {
    public static void main(String[] args) {
        // 在循环中调用方法
        for (int i = 1; i <= 3; i++) {
            System.out.println("第" + i + "次调用：");
            showMessage();
        }
        
        // 在条件语句中调用方法

运行这个程序会输出：

|
第1次调用：
这是一个方法调用
第2次调用：
这是一个方法调用
第3次调用：
这是一个方法调用
恭喜！你通过了考试！

向方法传递参数

参数传递

参数的概念

在编写方法时，很多情况下我们希望方法能够根据不同的输入数据执行不同的操作。为了实现这一点，我们可以在方法定义时指定参数（parameter），这样在调用方法时就可以将不同的数据传递给方法。方法内部可以使用这些参数来完成相应的逻辑处理。简单来说，参数就是方法用来接收外部传入数据的“占位符”，通过传递不同的参数，方法的行为也会随之变化。

参数和实参的区别

参数（Parameter）：参数是在方法定义时声明的变量，用于接收外部传入的数据。它们就像是方法的“占位符”，在方法体内部可以像普通变量一样使用。例如：
```
|
public static void greet(String name) {
    System.out.println("你好，" + name);
}
```
这里的 String name 就是参数。

实参（Argument）：实参是在调用方法时实际传递给方法的数据。实参可以是常量、变量、表达式等。方法调用时，实参的值会被赋给对应的参数。例如：

|
greet("小明");      // "小明" 是实参
String user = "小红";
greet(user);        // 变量 user 的值作为实参传递
greet("小" + "王"); // 表达式 "小" + "王" 的结果作为实参传递

单参数方法

有时候，我们希望方法能够根据传入的数据执行不同的操作。这时，可以为方法定义参数。下面我们通过一个例子，详细说明如何编写一个接收单个参数的方法，以及如何以不同方式传递参数给它：

|
public class SingleParameterDemo {
    public static void main(String[] args) {
        // 调用方法并传递不同的参数
        displayNumber(10);
        displayNumber(25);
        displayNumber(100);
        
        // 传递变量作为参数
        int myNumber = 42;
        displayNumber(myNumber);
        
        // 传递表达式作为参数

运行这个程序会输出：

|
你传递的数字是：10
你传递的数字是：25
你传递的数字是：100
你传递的数字是：42
你传递的数字是：8

多参数方法

方法也可以接收多个参数。下面我们通过一个例子，详细说明如何编写一个接收多个参数的方法，以及如何以不同方式传递参数给它：

|
public class MultipleParametersDemo {
    public static void main(String[] args) {
        // 调用多参数方法
        showSum(5, 10);
        showSum(20, 30);
        
        // 传递变量
        int a = 15;
        int b = 25;
        showSum(a, b);

运行这个程序会输出：

|
5 + 10 = 15
20 + 30 = 50
15 + 25 = 40
20 + 20 = 40

参数的数据类型

参数也可以是任何数据类型：

|
public class DataTypeParametersDemo {
    public static void main(String[] args) {
        // 传递不同类型的参数
        displayInfo("张三", 25, 1.75);
        displayInfo("李四", 30, 1.80);
        
        // 传递布尔值
        checkAge(18);
        checkAge(15);

运行这个程序会输出：

|
姓名：张三
年龄：25
身高：1.75米
----------------
姓名：李四
年龄：30
身高：1.8米
----------------
年龄：18，是否成年：true
年龄：15，是否成年：false

参数传递的注意事项

在编写方法时，需要注意以下几点：

数据类型匹配：传递的参数类型必须与方法参数类型兼容
参数顺序：传递参数时必须按照方法定义的顺序
参数数量：传递的参数数量必须与方法定义的参数数量一致

局部变量

局部变量的概念

局部变量是指在方法内部声明的变量。它们的作用范围（也叫“作用域”）仅限于当前方法的代码块内。也就是说：

局部变量只能在声明它们的方法中被访问和使用，方法外部无法直接访问这些变量。
当方法执行到声明局部变量的那一行时，变量才会被创建；当方法执行结束后，这些局部变量就会被销毁，内存空间也会被释放。
不同方法中可以声明同名的局部变量，它们互不影响，各自独立。
局部变量在使用前必须先赋值，否则编译器会报错。

局部变量的作用域

|
public class LocalVariableDemo {
    public static void main(String[] args) {
        // main方法的局部变量
        int mainVariable = 10;
        System.out.println("main方法中的变量：" + mainVariable);
        
        // 调用其他方法
        method1();
        method2();
        
        // 注意：这里无法访问method1和method2中的局部变量
        // System.out.println(method1Variable); // 错误！
    }

运行这个程序会输出：

|
main方法中的变量：10
method1中的变量：20
method2中的变量：30

局部变量的生命周期

局部变量的生命周期非常短暂：它们只在方法执行的过程中存在。当方法被调用时，局部变量才会被创建并分配内存；当方法执行结束后，这些局部变量就会被销毁，所占用的内存空间也会被释放。每次调用方法时，都会重新创建一份新的局部变量，彼此互不影响。因此，局部变量无法在方法外部访问，也不会在多次方法调用之间保留其值。

|
public class VariableLifetimeDemo {
    public static void main(String[] args) {
        System.out.println("第一次调用方法：");
        countCalls();
        
        System.out.println("第二次调用方法：");
        countCalls();
        
        System.out.println("第三次调用方法：");
        countCalls();
    }

运行这个程序会输出：

|
第一次调用方法：
这是第1次调用
第二次调用方法：
这是第1次调用
第三次调用方法：
这是第1次调用

有返回值方法

有返回值方法的概念

有返回值的方法不仅仅是执行某项任务，还会在任务完成后，将一个结果（返回值）交还给调用它的代码。你可以把它想象成餐厅里的“服务员”：你下单后，服务员不仅会帮你把菜点好，还会把做好的菜端到你面前。具体来说，有返回值的方法在执行完毕后，会通过return语句把一个值返回给调用者，这个值可以是任意类型（如int、double、String等），并且可以被赋值给变量、参与表达式运算，或者直接用于输出。这样，调用者就能根据方法返回的结果进行后续操作，实现更灵活和强大的程序逻辑。

定义有返回值方法

有返回值方法的语法如下：

|
public static 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;
}

第一个有返回值方法示例

|
public class ReturnValueDemo {
    public static void main(String[] args) {
        // 调用有返回值方法
        int result1 = add(5, 3);
        System.out.println("5 + 3 = " + result1);
        
        int result2 = multiply(4, 6);
        System.out.

运行这个程序会输出：

|
5 + 3 = 8
4 × 6 = 24
10 ÷ 3 = 3.3333333333333335
总结果：16

返回不同类型的值

在Java中，方法不仅可以返回基本数据类型（如int、double、char、boolean等），还可以返回引用类型（如String、数组、对象等）。这意味着你可以根据实际需求，让方法返回任意类型的数据。例如：

返回基本类型：如int、double、boolean等，常用于数值计算、状态判断等场景。
返回字符串（String）：常用于拼接和处理文本信息。
返回字符（char）：适合单个字符的判断或处理。
返回布尔值（boolean）：用于条件判断，表示真假、是否等。
返回数组：可以一次性返回一组数据，适合批量处理。
返回对象：可以将复杂的数据结构或多个相关数据通过对象封装后返回，便于后续操作和扩展。

下面通过代码示例详细演示方法如何返回不同类型的数据。

|
public class DifferentReturnTypesDemo {
    public static void main(String[] args) {
        // 返回字符串
        String fullName = getFullName("张", "三");
        System.out.println("全名：" + fullName);
        
        // 返回布尔值
        boolean isAdult = checkAge(20);
        System.out.println

运行这个程序会输出：

|
全名：张三
是否成年：true
成绩等级：B

返回对象引用

方法也可以返回对象的引用。下面我们通过一个例子，详细说明如何编写一个返回对象引用的方法，以及如何使用这个返回值：

|
import java.time.LocalDateTime;
 
public class ObjectReturnDemo {
    public static void main(String[] args) {
        // 返回当前时间
        LocalDateTime now = getCurrentTime();
        System.out.println("当前时间：" + now);
        
        // 返回问候语
        String greeting = getGreeting("张三");
        System.out.println(greeting);

方法的重用

代码重用的概念

方法的一个重要优势是代码重用。所谓代码重用，就是将一段实现特定功能的代码封装成方法（函数），这样在需要这个功能的地方，只需调用方法即可，无需每次都重新编写相同的实现细节。这不仅大大减少了代码的重复，提高了开发效率，还让程序结构更加清晰、易于维护和修改。

举例来说，如果你需要在程序的多个地方进行加法运算，只需编写一个加法方法，然后在不同的位置调用它即可。如果将来加法的实现需要调整，只需修改方法本身，所有调用该方法的地方都会自动获得最新的实现，无需逐一修改。这种方式极大地提升了代码的灵活性和可维护性。

此外，方法的重用还可以让大型程序的开发变得更加协作和模块化。不同的开发者可以分别负责不同的方法，各自实现和测试自己的功能，最后通过方法调用将各个部分组合成完整的系统。

实际应用示例

让我们创建一个简单的计算器程序，展示方法的重用：

|
public class CalculatorDemo {
    public static void main(String[] args) {
        // 使用相同的计算方法进行不同的计算
        int result1 = add(10, 20);
        int result2 = add(5, 15);
        int result3 = add(100, 200);

运行这个程序会输出：

|
10 + 20 = 30
5 + 15 = 20
100 + 200 = 300
4 × 5 = 20
6 × 7 = 42
(2×3) + (4×5) = 26

方法的层次调用

方法调用方法

在Java中，一个方法不仅可以独立完成某项任务，还可以在其内部调用其他方法，从而形成“层次化”的调用结构。这种结构类似于公司中的管理层级：上层方法负责整体流程的把控，下层方法各自专注于具体的细节处理。通过方法之间的相互调用，可以将复杂的问题拆解为多个小的、易于管理的步骤，每个方法只关注自己的职责。例如，主方法（main）可以调用一个数据处理方法，而数据处理方法又可以进一步调用输入验证、结果计算、结果展示等子方法。这样做的好处是让代码结构更加清晰、易于维护和扩展，也方便团队协作开发。

|
public class MethodHierarchyDemo {
    public static void main(String[] args) {
        System.out.println("开始主程序");
        
        // 主方法调用第一层方法
        processData();
        
        System.out.println("主程序结束");
    }
    
    // 第一层方法
    public static void processData() {
        System.out.

运行这个程序会输出：

|
开始主程序
进入数据处理方法
验证输入数据
计算结果
显示输出结果
数据处理完成
主程序结束

方法的文档注释

前面我们简单介绍了注释的作用，但在实际开发中，普通注释往往无法全面表达方法的用途、参数、返回值以及注意事项。此时，良好的文档注释（如Javadoc注释）就显得尤为重要。通过为每个方法编写详细的文档注释，不仅可以让其他程序员（包括未来的你）快速理解方法的功能、输入参数、返回值类型和可能的异常，还能提升代码的可维护性和可读性。

文档注释还能被自动化工具提取生成API文档，方便团队协作和后续开发。因此，养成为方法编写规范、详细的文档注释的习惯，是高质量Java编程的重要一环。

使用@param和@return标签

|
/**
 * 计算两个数的和
 * @param a 第一个数
 * @param b 第二个数
 * @return 两个数的和
 */
public static int add(int a, int b) {
    return a + b;
}
 
/**
 * 检查年龄是否成年
 * @param age 要检查的年龄
 * @return 如果年龄大于等于18返回true，否则返回false
 */

习题

在Java中，无返回值方法使用哪个关键字声明？

方法定义中，用于接收外部传入数据的部分是？

在Java中，有返回值方法如何返回值？

在方法内部声明的变量，只能在该方法内使用的变量称为？

调用方法时，必须与方法定义匹配的是？

以下哪个是无返回值方法的正确定义？

以下哪个是接收两个整数参数的方法的正确定义？

8. 无返回值方法练习

编写一个方法，显示个人信息（姓名、年龄、职业），并在main方法中调用它。

|
public class PersonalInfoDemo {
    public static void main(String[] args) {
        // 调用方法显示个人信息
        showPersonalInfo("张三", 25, "程序员");
        showPersonalInfo("李四", 30, "教师");
    }
    
    // 无返回值方法，显示个人信息
    public static void showPersonalInfo(String name

9. 有返回值方法练习

编写一个方法，计算圆的面积（接收半径参数，返回面积），并在main方法中使用返回值。

|
public class CircleAreaDemo {
    public static void main(String[] args) {
        // 调用方法并接收返回值
        double area1 = calculateCircleArea(5.0);
        System.out.println("半径为5.0的圆的面积: " + area1);
        
        double area2 = calculateCircleArea(10.0);
        System.out.println("半径为10.0的圆的面积: "

10. 多参数方法练习

编写一个方法，计算三个数的最大值，并在main方法中调用它。

|
public class MaxValueDemo {
    public static void main(String[] args) {
        // 调用方法计算最大值
        int max1 = findMax(10, 25, 15);
        System.out.println("10, 25, 15中的最大值: " + max1);
        
        int max2 = findMax(5, 3,

11. 方法调用练习

编写一个程序，使用多个方法完成简单的计算器功能（加法、减法、乘法、除法）。

|
public class CalculatorDemo {
    public static void main(String[] args) {
        int a = 20;
        int b = 5;
        
        // 调用不同的计算方法
        int sum = add(a, b);
        int difference = subtract(a, b);
        int product = multiply