在 Java 编程世界中，方法是构建高效、可维护代码的核心基石。无论是简单的数值计算，还是复杂的业务逻辑实现，方法都能将重复代码模块化、繁琐逻辑清晰化，让开发过程事半功倍。本文将从方法的本质出发，逐步拆解定义、调用、重载、递归等核心知识点，结合大量实战案例与底层原理分析，带你全方位掌握 Java 方法的使用技巧与设计思想，助力写出更优雅、更高效的 Java 代码。

一、为什么需要方法？—— 告别重复，拥抱高效

在编程实践中，我们经常会遇到需要反复执行的代码逻辑。比如判断一个年份是否为闰年、计算两个数的和、打印数组内容等。如果每次使用这些逻辑时都重新编写一遍代码，会带来一系列问题：

（一）无方法编程的痛点

代码冗余繁琐：相同逻辑在多个位置重复出现，导致代码量激增，阅读起来杂乱无章。
开发效率低下：重复编写相同代码浪费时间精力，无法专注于核心业务逻辑。
维护成本高昂：当需要修改该逻辑时，必须找到所有使用该代码的位置逐一修改，遗漏一处就可能引发 bug。
复用性极差：无法直接复用已有逻辑，只能复制粘贴，不符合 “DRY（Don't Repeat Yourself）” 编程原则。

（二）方法的核心价值

就像生活中老师将学生普遍遇到的笔试问题整理成一篇帖子，让所有有需要的同学直接查看，无需反复沟通一样，Java 中的方法就是对重复代码逻辑的 “帖子封装”。其核心价值体现在：

模块化组织代码：将复杂逻辑拆分为多个独立方法，每个方法负责单一功能，让代码结构清晰、易于理解。
代码复用：一份方法可以在多个位置调用，避免重复编写，提升开发效率。
简化维护：修改逻辑时只需调整方法内部实现，所有调用位置自动生效，降低维护成本。
降低复杂度：将大问题拆解为多个小方法，每个方法聚焦一个小功能，逐个解决即可完成复杂任务。

二、Java 方法的基础概念与定义

（一）什么是 Java 方法？

Java 中的方法（Method）本质上是一个封装了特定功能的代码片段，类似于 C 语言中的 “函数”。它是 Java 程序的基本执行单元，能够接收输入参数、执行特定操作，并返回结果（或无返回结果）。

简单来说，方法就是 “做某件事的固定步骤”—— 比如 “计算闰年” 的方法包含了判断闰年的逻辑步骤，“两数相加” 的方法包含了数值求和的步骤，调用方法就相当于 “执行这套固定步骤”。

（二）方法的语法格式

Java 方法的定义遵循严格的语法规则，完整格式如下：

修饰符 返回值类型 方法名称([参数类型 形参1, 参数类型 形参2, ...]) {
    方法体代码; // 方法的核心逻辑
    [return 返回值;] // 可选，根据返回值类型决定
}

1. 各部分详解

修饰符：用于限定方法的访问权限和行为特性。现阶段最常用的是public static组合 ——public表示该方法可以被其他类访问，static表示该方法是静态方法，无需创建对象即可调用。
返回值类型：方法执行完毕后返回结果的数据类型。如果方法没有返回值，必须指定为void；如果有返回值，返回值类型必须与return语句后的结果类型一致（如返回整数则为int，返回布尔值则为boolean）。
方法名称：遵循 “小驼峰命名法”—— 首字母小写，后续单词首字母大写（如isLeapYear、addTwoNumbers）。命名应见名知义，直接体现方法的功能。
参数列表：方法接收的输入数据，由 “参数类型 + 形参名” 组成，多个参数用逗号分隔。如果方法不需要输入数据，参数列表为空（括号内什么都不写）。
- 形参（形式参数）：方法定义时声明的变量，仅在方法内部有效，用于接收调用时传递的实际值。
- 实参（实际参数）：方法调用时传递给形参的具体值，必须与形参的类型、顺序、个数一一对应。
方法体：包裹在大括号中的代码块，包含了方法的核心逻辑 —— 即 “做某件事的具体步骤”。
return 语句：用于返回方法结果并结束方法执行。如果返回值类型是void，return可以省略（或仅写return;表示提前结束方法）；如果有返回值，必须通过return返回一个与返回值类型匹配的结果。

2. 定义注意事项

方法必须定义在类中，不能嵌套定义（即一个方法内部不能再定义另一个方法）。
方法名称与参数列表共同构成 “方法签名”，决定了方法的唯一性（后续重载章节详细说明）。
方法定义时不会执行方法体代码，只有调用时才会执行。

（三）基础示例：方法定义实战

示例 1：判断闰年的方法

public class MethodDemo {
    // 定义判断闰年的方法：接收int类型年份，返回boolean类型结果（true为闰年，false反之）
    public static boolean isLeapYear(int year) {
        // 闰年判断逻辑：能被4整除但不能被100整除，或能被400整除
        boolean result = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
        return result; // 返回判断结果
    }
}

示例 2：两数相加的方法

public class MethodDemo {
    // 定义两数相加的方法：接收两个int类型参数，返回它们的和（int类型）
    public static int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum; // 返回求和结果
    }
}

示例 3：无返回值的打印方法

public class MethodDemo {
    // 定义打印信息的方法：接收字符串参数，无返回值（void）
    public static void printMessage(String message) {
        System.out.println("输出信息：" + message);
        // 无return语句（或写return;）
    }
}

三、方法的调用与执行过程

方法定义后不会自动执行，必须通过 “调用” 触发。理解方法的调用过程是掌握方法使用的关键，包括调用语法、参数传递、执行流程等核心知识点。

（一）方法调用的语法格式

方法调用的核心是 “通过方法名找到方法地址，传递参数并执行方法体，最后返回结果”。调用语法分两种情况：

1. 有返回值的方法调用

// 格式：返回值类型 变量名 = 方法名(实参列表);
int result = add(10, 20); // 调用add方法，传递实参10和20，返回值存入result变量

2. 无返回值的方法调用

// 格式：方法名(实参列表);
printMessage("Hello, Java Method!"); // 直接调用printMessage方法，无需接收返回值

3. 注意事项

实参的类型、个数、顺序必须与形参完全匹配，否则会编译报错。
静态方法（带static修饰）直接通过 “类名。方法名 (实参)” 调用（如MethodDemo.add(10,20)），非静态方法需要先创建对象再调用（后续面向对象章节详解）。
方法可以嵌套调用（一个方法内部调用另一个方法），也可以递归调用（方法调用自身）。

（二）方法调用的执行流程

方法的执行过程可以拆解为以下步骤：

程序执行到方法调用语句时，暂停当前方法（主调方法）的执行。
将实参的值拷贝到形参（值传递），创建方法的栈帧并压入调用栈。
执行被调用方法的方法体代码，直到遇到return语句或方法体结束。
被调用方法执行完毕后，将返回值（如有）返回给主调方法，同时弹出该方法的栈帧。
主调方法从暂停的位置继续往下执行。

实战演示：方法调用流程分析

public class MethodCallDemo {
    public static void main(String[] args) {
        System.out.println("主方法开始执行");
        int a = 10;
        int b = 20;
        // 调用add方法
        int sum = add(a, b);
        System.out.println("两数之和：" + sum);
        System.out.println("主方法执行结束");
    }

    public static int add(int num1, int num2) {
        System.out.println("add方法开始执行：num1=" + num1 + ", num2=" + num2);
        int result = num1 + num2;
        System.out.println("add方法执行结束：result=" + result);
        return result;
    }
}

执行结果与流程解析：

主方法开始执行
add方法开始执行：num1=10, num2=20
add方法执行结束：result=30
两数之和：30
主方法执行结束

流程拆解：

程序启动后，先执行main方法（Java 程序的入口方法），打印 “主方法开始执行”。
定义变量a=10、b=20，执行add(a, b)调用add方法。
暂停main方法执行，将实参a=10、b=20拷贝到add方法的形参num1、num2。
执行add方法体，打印 “add 方法开始执行”，计算result=30，打印 “add 方法执行结束”，返回result=30。
add方法栈帧弹出，main方法恢复执行，将返回值30存入sum变量。
打印 “两数之和：30” 和 “主方法执行结束”，程序终止。

（三）调用栈与栈帧的概念

在 JVM（Java 虚拟机）中，方法的调用过程通过 “调用栈”（Call Stack）管理，调用栈是一种先进后出（LIFO）的内存结构，每个方法调用都会创建一个 “栈帧”（Stack Frame）并压入栈中。

1. 栈帧的组成

每个栈帧包含以下信息：

局部变量表：存储方法的形参和局部变量。
操作数栈：用于方法执行过程中的数值运算和数据传递。
方法返回地址：记录方法执行完毕后回到主调方法的位置。

2. 调用栈的运作过程

以上述MethodCallDemo为例，调用栈的变化的过程：

程序启动，main方法的栈帧压入调用栈，成为栈顶。
调用add方法时，add方法的栈帧压入栈顶，main方法栈帧暂时处于非栈顶状态。
add方法执行完毕后，其栈帧弹出，返回值传递给main方法。
main方法栈帧重新成为栈顶，继续执行后续代码。
main方法执行完毕后，其栈帧弹出，调用栈为空，程序终止。

理解调用栈和栈帧有助于排查递归溢出、方法调用顺序等问题，是深入 Java 底层的基础。

四、实参与形参的关系：值传递的核心原理

Java 中方法参数的传递方式是 “值传递”—— 即实参的值会被拷贝一份传递给形参，形参和实参是两个独立的变量，修改形参的值不会影响实参。这是 Java 方法传参的核心规则，也是新手容易混淆的知识点。

（一）基础类型的参数传递

Java 中的基础类型（byte、short、int、long、float、double、boolean、char）在传参时，传递的是变量的 “值拷贝”。形参的修改仅作用于自身，与实参无关。

示例：交换两个整数（值传递演示）

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

    // 定义交换方法
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
        System.out.println("swap方法中：x=" + x + ", y=" + y);
    }
}

执行结果：

交换前：a=10, b=20
swap方法中：x=20, y=10
交换后：a=10, b=20

结果分析：

实参a=10、b=20的值被拷贝到形参x、y，此时x=10、y=20。
swap方法中交换的是x和y的值（形参），实参a和b的内存地址并未改变。
因此，swap方法执行完毕后，实参a和b的值仍然是 10 和 20，交换失败。

（二）引用类型的参数传递

Java 中的引用类型（数组、类、接口等）在传参时，传递的是 “引用地址的值拷贝”—— 即实参存储的对象地址被拷贝给形参，形参和实参指向同一个对象。此时修改形参指向的对象内容，会影响实参指向的对象（因为两者指向同一个内存地址），但修改形参的引用地址（让形参指向其他对象）不会影响实参。

示例：通过数组交换两个整数（引用类型传参）

public class ReferenceTransferDemo {
    public static void main(String[] args) {
        int[] arr = {10, 20}; // 数组是引用类型
        System.out.println("交换前：arr[0]=" + arr[0] + ", arr[1]=" + arr[1]);
        swap(arr); // 传递数组的引用地址
        System.out.println("交换后：arr[0]=" + arr[0] + ", arr[1]=" + arr[1]);
    }

    // 定义交换数组元素的方法
    public static void swap(int[] array) {
        int temp = array[0];
        array[0] = array[1];
        array[1] = temp;
        System.out.println("swap方法中：array[0]=" + array[0] + ", array[1]=" + array[1]);
    }
}

执行结果：

交换前：arr[0]=10, arr[1]=20
swap方法中：array[0]=20, array[1]=10
交换后：arr[0]=20, arr[1]=10

结果分析：

实参arr是数组的引用地址（指向内存中的数组对象），传参时将该地址拷贝给形参array。
arr和array指向同一个数组对象，因此swap方法中修改array指向的数组元素，本质上是修改了同一个数组对象的内容。
方法执行完毕后，实参arr指向的数组元素已被交换，交换成功。

（三）值传递的核心总结

Java 中只有 “值传递”，没有 “引用传递”—— 引用类型传参传递的是 “引用地址的值拷贝”，本质还是值传递。
基础类型传参：形参是实参的 “值拷贝”，修改形参不影响实参。
引用类型传参：形参是实参引用地址的 “值拷贝”，修改形参指向的对象内容会影响实参，但修改形参的引用地址（如array = new int[2]）不会影响实参。

五、方法重载：灵活处理多样需求

在实际开发中，经常需要实现功能相似但参数不同的方法（如计算两个整数的和、两个小数的和、三个整数的和等）。如果为每个方法起不同的名字（如addInt、addDouble、addThreeInt），会导致方法名杂乱、不易记忆。Java 的 “方法重载”（Overload）机制正是为解决这个问题而设计。

（一）方法重载的概念

方法重载是指：在同一个类中，多个方法的方法名相同，但参数列表不同（参数个数不同、参数类型不同、参数类型顺序不同），则称这些方法为重载方法。

重载的核心是 “方法名相同，参数列表不同”，与返回值类型、修饰符无关。编译器会根据实参的类型、个数、顺序自动匹配对应的方法。

（二）方法重载的条件

方法名必须完全相同。
参数列表必须不同（满足以下任一条件）：
- 参数个数不同（如add(int a, int b)和add(int a, int b, int c)）。
- 参数类型不同（如add(int a, int b)和add(double a, double b)）。
- 参数类型顺序不同（如add(int a, double b)和add(double a, int b)）。
与返回值类型无关（如int add(int a, int b)和double add(int a, int b)不能构成重载，会编译报错）。
与修饰符无关（如public static int add(...)和private static int add(...)不能构成重载，因为参数列表相同）。

（三）方法重载的实战示例

示例 1：不同参数类型的重载

public class OverloadDemo {
    // 两个整数相加
    public static int add(int a, int b) {
        System.out.println("调用int add(int a, int b)");
        return a + b;
    }

    // 两个小数相加（参数类型不同）
    public static double add(double a, double b) {
        System.out.println("调用double add(double a, double b)");
        return a + b;
    }

    public static void main(String[] args) {
        int sum1 = add(10, 20); // 匹配int add(int a, int b)
        double sum2 = add(10.5, 20.5); // 匹配double add(double a, double b)
        System.out.println("sum1=" + sum1 + ", sum2=" + sum2);
    }
}

执行结果：

调用int add(int a, int b)
调用double add(double a, double b)
sum1=30, sum2=31.0

示例 2：不同参数个数的重载

public class OverloadDemo2 {
    // 两个整数相加
    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 int add(int a, int b, int c, int d) {
        return a + b + c + d;
    }

    public static void main(String[] args) {
        int sum2 = add(1, 2); // 2个参数
        int sum3 = add(1, 2, 3); // 3个参数
        int sum4 = add(1, 2, 3, 4); // 4个参数
        System.out.println("sum2=" + sum2 + ", sum3=" + sum3 + ", sum4=" + sum4);
    }
}

执行结果：

sum2=3, sum3=6, sum4=10

示例 3：不同参数顺序的重载

public class OverloadDemo3 {
    // 先int后double
    public static void printInfo(int num, double price) {
        System.out.println("编号：" + num + ", 价格：" + price);
    }

    // 先double后int（参数顺序不同）
    public static void printInfo(double price, int num) {
        System.out.println("价格：" + price + ", 编号：" + num);
    }

    public static void main(String[] args) {
        printInfo(1001, 99.9); // 匹配int, double
        printInfo(89.9, 1002); // 匹配double, int
    }
}

执行结果：

编号：1001, 价格：99.9
价格：89.9, 编号：1002

（四）方法重载的底层原理：方法签名

为什么同一个类中可以有多个方法名相同的方法？这涉及到 Java 的 “方法签名” 机制。

方法签名是编译器在编译后生成的方法唯一标识，其组成规则为：方法全路径名 + 参数列表 + 返回值类型（注意：不同编译器可能略有差异，但核心是 “参数列表” 决定唯一性）。

例如，对于以下两个重载方法：

public static int add(int a, int b) { ... }
public static double add(double a, double b) { ... }

编译后生成的方法签名（简化版）为：

add:(II)I（II 表示两个 int 参数，I 表示返回 int）
add:(DD)D（DD 表示两个 double 参数，D 表示返回 double）

编译器在调用方法时，会根据实参的类型、个数、顺序推演，匹配对应的方法签名，从而找到正确的方法执行。这也是重载方法能被正确区分的底层原因。

（五）方法重载的使用场景与优势

1. 适用场景

当需要实现 “功能相似但输入参数不同” 的逻辑时，优先使用方法重载。例如：

计算不同类型（int、double）、不同个数的数值之和。
打印不同类型（String、int、数组）的数据。
构造对象时接收不同的初始化参数（构造方法重载，后续面向对象章节详解）。

2. 核心优势

简化方法命名：无需为相似功能的方法起不同名字，降低记忆成本。
提升代码可读性：方法名统一，通过参数列表区分不同用法，代码更简洁直观。
增强代码灵活性：调用时根据实际需求传递不同参数，编译器自动匹配对应方法，开发更高效。

六、递归：解决复杂问题的优雅方式

递归是一种强大的编程思想，其核心是 “方法调用自身”。在解决某些复杂问题时（如阶乘计算、斐波那契数列、树结构遍历等），递归能将问题拆解为更小的子问题，用简洁的代码实现复杂逻辑。但递归也是一把 “双刃剑”，使用不当会导致栈溢出、效率低下等问题。

（一）递归的概念与本质

递归（Recursion）：一个方法在执行过程中直接或间接调用自身，称为递归。

递归的本质是 “分治思想”—— 将原问题拆解为与原问题结构相同但规模更小的子问题，子问题继续拆解，直到达到 “递归出口”（终止条件），然后逐层返回结果，最终解决原问题。

就像老和尚给小和尚讲故事：“从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的是……”，故事的结构不断重复，直到某个终止点。

（二）递归的必要条件

要写出正确的递归方法，必须满足两个核心条件，缺一不可：

递归出口：存在一个明确的终止条件，当满足该条件时，递归停止（否则会陷入无限递归，导致栈溢出）。
子问题与原问题结构相同：原问题可以拆解为与自身结构一致的子问题，子问题的解法与原问题相同。

（三）递归的实战示例

示例 1：递归计算 N 的阶乘

阶乘定义：n! = n × (n-1) × (n-2) × ... × 1（0! = 1，1! = 1）。

递归分析：

递归出口：n == 1或n == 0时，返回 1。
递归公式：n! = n × (n-1)!（原问题n!拆解为子问题(n-1)!）。

代码实现：

public class RecursionDemo {
    // 递归计算n的阶乘
    public static int factorial(int n) {
        // 递归出口
        if (n == 0 || n == 1) {
            return 1;
        }
        // 递归公式：n! = n * (n-1)!
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int n = 5;
        int result = factorial(n);
        System.out.println(n + "! = " + result); // 输出：5! = 120
    }
}

递归执行流程分析：

factorial(5) = 5 × factorial(4)
factorial(4) = 4 × factorial(3)
factorial(3) = 3 × factorial(2)
factorial(2) = 2 × factorial(1)
factorial(1) = 1（递归出口）
// 逐层返回
factorial(2) = 2 × 1 = 2
factorial(3) = 3 × 2 = 6
factorial(4) = 4 × 6 = 24
factorial(5) = 5 × 24 = 120

示例 2：递归打印数字的每一位

需求：输入一个整数（如 1234），按顺序打印其每一位（1 2 3 4）。

递归分析：

递归出口：数字num < 10时，直接打印该数字。
递归公式：先打印num / 10的每一位（子问题），再打印num % 10（当前位）。

代码实现：

public class RecursionDemo2 {
    // 递归打印数字的每一位
    public static void printDigits(int num) {
        // 递归出口：数字小于10，直接打印
        if (num < 10) {
            System.out.print(num + " ");
            return;
        }
        // 子问题：打印num/10的每一位
        printDigits(num / 10);
        // 打印当前位（num%10）
        System.out.print(num % 10 + " ");
    }

    public static void main(String[] args) {
        printDigits(1234); // 输出：1 2 3 4
    }
}

示例 3：递归求斐波那契数列第 N 项

斐波那契数列定义：第 1 项和第 2 项为 1，从第 3 项开始，每一项等于前两项之和（fib(n) = fib(n-1) + fib(n-2)）。

递归分析：

递归出口：n == 1或n == 2时，返回 1。
递归公式：fib(n) = fib(n-1) + fib(n-2)。

代码实现：

public class RecursionDemo3 {
    // 递归求斐波那契数列第n项
    public static int fibonacci(int n) {
        // 递归出口
        if (n == 1 || n == 2) {
            return 1;
        }
        // 递归公式
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        int n = 10;
        int result = fibonacci(n);
        System.out.println("斐波那契数列第" + n + "项：" + result); // 输出：55
    }
}

（四）递归的问题与优化

1. 递归的潜在问题

栈溢出风险：每次递归调用都会创建新的栈帧，若递归深度过大（如fibonacci(1000)），会导致调用栈溢出（StackOverflowError）。
重复计算：如斐波那契数列的递归实现，计算fib(5)时会重复计算fib(3)、fib(2)等多次，导致效率极低（fib(40)需要计算数千万次重复项）。

2. 优化方案

递归转循环：将递归逻辑改为循环，避免栈溢出和重复计算（如斐波那契数列的循环实现）。

// 循环实现斐波那契数列（优化版）
public static int fibonacciOpt(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    int prevPrev = 1; // fib(n-2)
    int prev = 1;    // fib(n-1)
    int current = 0; // fib(n)
    for (int i = 3; i <= n; i++) {
        current = prev + prevPrev;
        prevPrev = prev;
        prev = current;
    }
    return current;
}

记忆化递归：使用数组或哈希表存储已计算的子问题结果，避免重复计算（适用于递归深度不大但重复计算严重的场景）。

// 记忆化递归实现斐波那契数列
public static int fibonacciMemo(int n, int[] memo) {
    if (n == 1 || n == 2) {
        return 1;
    }
    // 若已计算过，直接返回缓存结果
    if (memo[n] != 0) {
        return memo[n];
    }
    // 计算并缓存结果
    memo[n] = fibonacciMemo(n - 1, memo) + fibonacciMemo(n - 2, memo);
    return memo[n];
}

public static void main(String[] args) {
    int n = 40;
    int[] memo = new int[n + 1]; // 缓存数组
    int result = fibonacciMemo(n, memo);
    System.out.println(result); // 高效输出结果
}

（五）递归的适用场景

递归并非万能，以下场景更适合使用递归：

问题可以自然拆解为与自身结构相同的子问题（如阶乘、斐波那契数列）。
数据结构本身具有递归特性（如树、链表、图的遍历）。
问题的迭代实现过于复杂（如汉诺塔问题、迷宫问题）。

七、方法的高级用法与最佳实践

（一）方法的嵌套调用与链式调用

1. 嵌套调用

Java 中方法不能嵌套定义，但可以嵌套调用 —— 即一个方法内部调用另一个方法，甚至多个方法相互调用。

示例：

public class NestedCallDemo {
    // 计算两数之和
    public static int add(int a, int b) {
        return a + b;
    }

    // 计算两数之积
    public static int multiply(int a, int b) {
        return a * b;
    }

    // 计算 (a+b)*(c+d)
    public static int calculate(int a, int b, int c, int d) {
        int sum1 = add(a, b); // 嵌套调用add方法
        int sum2 = add(c, d); // 嵌套调用add方法
        return multiply(sum1, sum2); // 嵌套调用multiply方法
    }

    public static void main(String[] args) {
        int result = calculate(1, 2, 3, 4);
        System.out.println("(1+2)*(3+4) = " + result); // 输出：21
    }
}

2. 链式调用

链式调用是指方法返回当前对象（this），从而可以连续调用多个方法。这种方式常用于构建器模式（Builder Pattern），让代码更简洁。

示例：

class Calculator {
    private int result;

    public Calculator add(int num) {
        result += num;
        return this; // 返回当前对象
    }

    public Calculator multiply(int num) {
        result *= num;
        return this; // 返回当前对象
    }

    public int getResult() {
        return result;
    }
}

public class ChainCallDemo {
    public static void main(String[] args) {
        // 链式调用：连续调用add和multiply方法
        int result = new Calculator()
                .add(2)
                .add(3)
                .multiply(4)
                .getResult();
        System.out.println("(2+3)*4 = " + result); // 输出：20
    }
}