【Java零基础30天挑战·Day6】代码的封装艺术：一文彻底搞懂Java方法（函数）

Eliaukzfy

504人浏览 · 2026-06-14 14:03:06

Eliaukzfy · 2026-06-14 14:03:06 发布

代码的封装艺术：一文彻底搞懂Java方法（函数）

📝 前言：在前两篇博客中，我们学习了分支和循环，让程序有了“判断”和“重复”的能力。但你有没有想过，如果一段处理逻辑需要多次使用，难道每次都要把代码复制粘贴一遍吗？这不仅让代码臃肿不堪，一旦逻辑需要修改，你得在一堆“屎山”里找遍所有粘贴的地方。

为了复用代码和提升可读性，编程界引入了最伟大的发明之一——函数。在Java的面向对象世界里，我们习惯称之为方法。

今天，我们就来彻底拆解Java方法的方方面面，从基础语法到进阶避坑，让你写出像源码一样优雅的代码！🚀

🏭 一、什么是方法？

举个生活中的例子：榨汁机。

输入：苹果、水、糖（参数）
处理：搅拌、粉碎（方法体）
输出：一杯苹果汁（返回值）

你不需要知道榨汁机内部电机怎么转，你只需要把水果放进去，它就会给你果汁。方法，就是一段具有独立功能的代码块，它将实现细节封装起来，只对外暴露接口。

🛠️ 二、方法的定义与语法

在Java中，定义一个方法就像填写一张说明书：

// 语法格式
修饰符 返回值类型 方法名(参数列表) {
    // 方法体（具体的业务逻辑）
    return 返回值;
}

语法拆解：

修饰符：比如 public（谁能用它）、static（静态方法，可通过类名直接调用）。
返回值类型：方法执行完后产出的结果类型。如果没有产出，必须写 void（空）。
方法名：见名知意，小驼峰命名法（如 getMax）。
参数列表：方法执行需要的原材料。分为形参（定义时的占位符）和实参（调用时传进去的真实数据）。
return：交出返回值，并立刻结束当前方法。

// 完整示例：定义一个求最大值的方法
public static int getMax(int a, int b) { // a,b是形参
    int max = a > b ? a : b;
    return max; // 返回int类型的结果
}

📞 三、方法的调用

方法定义了不调用，就是摆设。怎么调用呢？

1. 基础调用

public static void main(String[] args) {
    int res = getMax(10, 20); // 10,20是实参，用变量res接收返回值
    System.out.println("最大值是：" + res); // 输出：20
}

2. 值传递的真相（🔥面试必考/新手必踩坑）

Java中方法的参数传递只有一种：值传递。但根据数据类型的不同，表现有天壤之别：

基本数据类型（int, double等）：传递的是数据的拷贝。方法内修改拷贝，不影响外面的原始数据。
引用数据类型（数组、对象等）：传递的是地址值的拷贝。方法内通过地址修改属性，外面的数据会跟着变！

public static void main(String[] args) {
    // 1. 基本类型：不改变原值
    int x = 10;
    change(x);
    System.out.println("main中的x = " + x); // 依然是 10

    // 2. 引用类型：改变原数组
    int[] arr = {1, 2, 3};
    changeArr(arr);
    System.out.println("main中的arr[0] = " + arr[0]); // 变成了 99
}

public static void change(int num) {
    num = 100; // 只是改了副本
}

public static void changeArr(int[] array) {
    array[0] = 99; // 通过地址值，修改了真实的数组内容
}

🔀 四、方法的重载

有时候，我们需要做“同一件事”，但原材料不一样。比如求两个数的和，可能是int+int，也可能是double+double。如果非要起不同的名字（addInt, addDouble），简直反人类。

方法重载完美解决了这个问题：同名不同参，编译器自动匹配。

重载的三大铁律（缺一不可）：

方法名必须相同。
参数列表必须不同（类型不同、个数不同、顺序不同）。
与返回值类型无关！（不能仅靠返回值不同来重载）。

// 经典重载示例：System.out.println() 就是超级重载王，啥类型都能打印！
public static int add(int a, int b) {
    return a + b;
}

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

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

🪆 五、进阶：方法的递归

递归，就是方法自己调用自己。这就像你站在两面相对的镜子中间，看到了无限延伸的倒影。

递归的核心思想是把大问题拆解成同类型的子问题。但递归必须要有“出口”，否则就是死循环，直接撑爆内存。

// 示例：计算 1+2+3+...+n
public static int getSum(int n) {
    if (n == 1) {
        return 1; // 🚨 递归的出口（基线条件）
    } else {
        return n + getSum(n - 1); // 递归调用
    }
}

⚠️ 避坑指南：递归虽然代码优雅，但每次调用都会在栈内存中开辟新空间。如果递归层级太深（比如算 getSum(100000)），会抛出著名的 StackOverflowError（栈溢出）。在Java中，能用循环解决的，尽量不用递归！

💎 六、如何写出优雅的方法？（企业级规范）

在实际开发中，写代码不是写给机器看的，是写给人看的。糟糕的方法设计是团队协作的毒药。

1. 单一职责原则（SRP）

一个方法只做一件事！如果一个方法既负责查询数据库，又负责发送邮件，还负责更新缓存，这就是灾难。

// ❌ 糟糕的写法：干的事太杂
public void processOrder(Order order) {
    // 1. 保存订单
    // 2. 扣减库存
    // 3. 发短信通知
}

// ✅ 优雅的写法：拆分为多个专职方法
public void saveOrder(Order order) { ... }
public void deductStock(Order order) { ... }
public void sendSms(Order order) { ... }

2. 参数不宜过多

参数超过3个，调用者就会抓狂，容易传错顺序。

如果参数多，考虑封装成一个对象（DTO）。

// ❌ 糟糕的写法：参数又多又乱
public void register(String name, int age, String phone, String email, String address) { ... }

// ✅ 优雅的写法：封装对象
public void register(UserInfo userInfo) { ... }