11个值得借鉴的Java return写法分享

目录

• 前言
• 1. 提前返回（卫语句）：让主逻辑更清晰
• 2. 避免 return 后的 else 块
• 3. 简化布尔返回
• 4. 减少不必要的临时变量
• 5. 巧用三元运算符
• 6. 返回空集合而非 null
• 7. 利用 Optional 优雅处理可能缺失的值
• 8. 循环中的提前返回
• 9. 利用 switch 表达式（Java 14+）
• 10. 返回更有意义的类型（枚举或自定义对象）
• 11. 注意 finally 块中的 return（陷阱！）
• 结尾

前言

return 这个关键字，相信大家每天都在用。

它就像一把锤子，敲打着我们代码里的每一个出口。

但扪心自问，我们真的把这把锤子用好了吗？

今天，不想聊什么高深莫测的设计模式，也不敢妄称“最佳实践”。

只想结合自己这些年在项目摸爬滚打中踩过的一些坑、积累的一点心得，和大家分享一些关于 return 的、或许能让我们的代码更规范、更优雅、更易读的写法。

权当抛砖引玉，希望能引发大家的一些思考。

耐心看完，你一定有所收获。

1. 提前返回（卫语句）：让主逻辑更清晰

这是最常见也是非常推荐的一种模式。

核心思想是：在方法开头处理掉所有“异常”或“特殊”情况android，让方法的主体部分专注于核心逻辑。

反面教android材 ：

public void processData(Data data) {
    if (data != null) {
        if (data.isValid()) {
            if (checkPermission(data)) {
                // 核心逻辑开始...
                System.out.println("处理数据：" + data.getContent());
                // ...
                // 大量核心代码嵌套在这里
                // ...
                System.out.println("处理完成");
            } else {
                System.out.println("权限不足");
            }
        } else {
            System.out.println("数据无效");
        }
    } else {
        System.out.println("数据为null");
    }
}

很难评，嵌套过深，核心逻辑被包裹在层层 if-else 中，可读性太差。

推荐写法 ：

public void processData(Data data) {
    if (data == null) {
        System.out.println("数据为null");
        return; // 提前返回
    }
    if (!data.isValid()) {
        System.out.println("数据无效");
        return; // 提前返回
    }
    if (!checkPermission(data)) {
        System.out.println("权限不足");
        return; // 提前返回
    }

    // --- 核心逻辑开始 ---
    // 经过前面的卫语句检查，这里的data一定是有效且有权限的
    System.out.println("处理数据：" + data.getContent());
    // ...
    // 核心代码不再嵌套，非常清晰
    // ...
    System.out.println("处理完成");
}

通过提前 return，避免了深层嵌套，让主要的处理流程更加顺畅，代码逻辑一目了然。

配得上“优雅”二字。

2. 避免 return 后的 else 块

当 if 分支中包含 return 语句时，其后的代码天然就是 else 的逻辑，无需显式写出 else。

反面教材 ：

public String getStatus(int code) {
    if (code == 0) {
        return "Success";
    } else {
        // 其他逻辑
        return "Error: " + getErrorMessage(code);
    }
}

虽然没错，但 else 显得有些多余，未免画蛇添足。

推荐写法 ：

public String getStatus(int code) {
    if (code == 0) {
        return "Success";
    }
    // 如果 code == 0，上面的 return 已经退出方法了
    // 能执行到这里，说明 code != 0，天然就是 else 的逻辑
    return "Error: " + getErrorMessage(code);
}

代码更简洁，减少了一层不必要的缩进。

3. 简化布尔返回

直接返回布尔表达式的结果，而不是使用 if-else 返回 true 或 false。

反面教材 ：

public boolean isEligible(User user) {
    if (user.getAge() >= 18 && user.isActive()) {
        return true;
    } else {
        return false;
    }
}

点评：非常啰嗦。

推荐写法 ：

public boolean isEligible(User user) {
    return user.getAge() >= 18 && user.isActive();
}

一行搞定，清晰明了。

4. 减少不必要的临时变量

如果一个变量仅仅是为了存储即将 return 的值，可以考虑直接 return 表达式的结果。

反面教材：

public int calculateSum(int a, int b) {
    int sum = a + b;
    return sum;
}

public String getUserGreeting(User user) {
    String greeting = "Hello, " + user.getName();
    return greeting;
}

sum 和 greeting 变量并非必需。

推荐写法 ：

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

public String getUserGreeting(User user) {
    // 如果 user.getName() 调用成本高或需要复用，临时变量可能有意义
    // 但在这个简单场景下，直接返回更简洁
    re编程客栈turn "Hello, " + user.getName();
}

更直接。

但注意，如果表达式复杂或计算结果需要复用，还是考虑使用临时变量，可以提高可读性或效率，需要权衡。

5. 巧用三元运算符

对于简单的二选一返回逻辑，三元运算符 ?: 是 if-else 的简洁替代。

反面教材 ：

public String getLevel(int score) {
    String level;
    if (score >= 60) {
        level = "Pass";
    } else {
        level = "Fail";
    }
    return level;
}

推荐写法 ：

public String getLevel(int score) {
    return score >= 60 ? "Pass" : "Fail";
}

一行代码，清晰表达了条件选择。

但是编程客栈千万注意不要滥用，过分嵌套的三元运算符会降低可读性。

6. 返回空集合而非 null

方法约定返回集合类型（List, Set, Map等）时，如果没有数据，应返回空集合而不是 null。

这可以避免调用方不必要的 null 检查。

反面教材 ：

public List<String> getUsers(String department) {
    List<String> users = findUsersByDepartment(department);
    if (users.isEmpty()) { // 或者 users == null
        return null; // 调用方需要检查 null !
    }
    return users;
}

推荐写法 ：

import java.util.Collections;
import java.util.List;

public List<String> getUsers(String department) {
    List<String> users = findUsersByDepartment(department);
    // 假设 findUsersByDepartment 可能返回 null 或空 List
    if (users == null || users.isEmpty()) {
        return Collections.emptyList(); // 返回不可变的空列表
    }
    // 或者更好的是，确保 findUsersByDepartment 内部就返回空列表而不是 null
    return users;
}

// 调用方代码，无需担心 NullPointerException
List<String> userList = service.getUsers("IT");
for (String user : userList) { // 直接遍历，安全
    System.out.println(user);
}

调用方代码更健壮、简洁，符合“防御性编程”的原则。

7. 利用 Optional 优雅处理可能缺失的值

当方法可能返回一个值，也可能什么都不返回时，使用 Optional<T> 作为返回类型比返回 null 更能明确表达这种可能性，并引导调用方正确处理。

反面教材 ：

public User findUserById(String id) {
    // ... 查询逻辑 ...
    if (found) {
        return user;
    } else {
        return null; // 调用方必须检查 null
    }
}

// 调用方
User user = findUserById("123");
if (user != null) { // 繁琐的 null 检查
    System.out.println(user.getName());
}

推荐写法 ：

import java.util.Optional;

public Optional<User> findUserById(String id) {
    // ... 查询逻辑 ...
    if (found) {
        return Optional.of(user);
    } else {
        return Optional.empty();
    }
}

// 调用方
findUserById("123")
    .ifPresent(user -> System.out.println(user.getName())); // 清晰地处理存在的情况

// 或者提供默认值
String userName = findUserById("123")
                    .map(User::getName)
                    .orElse("Unknown User");

Optional 强制调用者思考值不存在的情况，并通过链式调用提供了更流畅的处理方式，减少空指针风险。

但是Java的Optional非常头疼，如果使用时不加注意，本应返回Optional的方法，返回了null，反而会增加负担，因此团队的开发规范至关重要。

8. 循环中的提前返回

在循环中查找元素或满足某个条件时，一旦找到或满足，应立即 return，避免不必要的后续迭代。

反面教材 ：

public Product findProductByName(List<Product> products, String name) {
    Product foundProduct = null;
    for (Product product : products) {
        if (product.getName().equals(name)) {
            foundProduct = product;
            break; // 找到后跳出循环
        }
    }
    // 循环结束后再返回
    return foundProduct;
}

需要一个额外的 foundProduct 变量，并且在循环外返回。

浪费性能。

推荐写法 ：

public Product findProductByName(List<Product> products, String name) {
    for (Product product : products) {
        if (product.getName().equals(name)) {
           编程 return product; // 一旦找到，立即返回
        }
    }
    // 循环正常结束，说明没找到
    return null; // 或者 Optional.empty()
}

逻辑更直接，代码更紧凑。

9. 利用 switch 表达式（Java 14+）

现在Java的 switch 表达式可以直接返回值，使得基于多分支选择的返回更加简洁。

反面教材  (传统 switch 语句):

public String getWeekdayType(DayOfWeek day) {
    String type;
    switch (day) {
        case MONDAY:
        case TUESDAY:
        case WEDNESDAY:
        case THURSDAY:
        case FRIDAY:
            type = "Workday";
            break;
        case SATURDAY:
        case SUNDAY:
            type = "Weekend";
            break;
        default:
            throw new IllegalArgumentException("Invalid day: " + day);
    }
    return type;
}

推荐写法 (使用 switch 表达式):

public String getWeekdayType(DayOfWeek day) {
    return switch (day) {
        case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Workday";
        case SATURDAY, SUNDAY -> "Weekend";
        // default 分支通常是必需的，除非覆盖了所有枚举常量
        // 如果逻辑确定上面的 case 已经覆盖所有情况，可以不写 default，
        // 但如果传入未覆盖的值会抛异常。
        // 或者明确处理:
        // default -> throw new IllegalArgumentException("Invalid day: " + day);
    };
}

代码量显著减少，-> 语法更直观，且 switch 表达式要求覆盖所有情况（或有 default），更安全。

10. 返回更有意义的类型（枚举或自定义对象）

避免使用魔法数字或含义模糊的字符串作为返回码，应返回定义清晰的枚举或包含状态和信息的自定义结果对象。

反面教材 ：

public int processOrder(Order order) {
    if (order == null) return -1; // -1 代表失败
    if (!checkInventory(order)) return 1; // 1 代表库存不足
    // ... 处理 ...
    if (!paymentSuccess(order)) return 2; // 2 代表支付失败

    return 0; // 0 代表成功
}

// 调用方
int resultCode = processOrder(myOrder);
if (resultCode == 0) { ... }
else if (resultCode == 1) { ... } // 难以理解和维护

推荐写法 ：

public enum OrderStatus { SUCCESS, FAILED_NULL_ORDER, FAILED_INVENTORY, FAILED_PAYMENT }

public OrderStatus processOrder(Order order) {
    if (order == null) return OrderStatus.FAILED_NULL_ORDER;
    if (!checkInventory(order)) return OrderStatus.FAILED_INVENTORY;
    // ... 处理 ...
    if (!paymentSuccess(order)) return OrderStatus.FAILED_PAYMENT;

    return OrderStatus.SUCCESS;
}

// 调用方
OrderStatus status = processOrder(myOrder);
if (status == OrderStatus.SUCCESS) { ... }
else if (status == OrderStatus.FAILED_INVENTORY) { ... } // 清晰易懂

返回类型本身就携带了业务含义，代码自解释，更易于维护和扩展。

11. 注意 finally 块中的 return（陷阱！）

尽量避免在 finally 块中使用 return。

它会覆盖 try 或 catch 块中的 return 或抛出的异常，可能导致非预期的行为和难以追踪的 Bug。

反面教材 (极不推荐):

public int trickyReturn() {
    try {
        System.out.println("Trying...");
        // 假设这里发生异常或正常返回 1
        // throw new RuntimeException("Oops!");
        return 1;
    } catch (Exception e) {
        System.out.println("Caught exception");
        return 2; // 试图在 catch 中返回 2
    } finally {
        System.out.println("Finally block");
        return 3; // finally 中的 return 会覆盖前面的所有返回/异常！
    }
    // 这个方法最终会返回 3，即使 try 或 catch 中有 return 或抛出异常
}

finally 的主要目的是资源清理（如关闭流、释放锁），而不是返回值。

在这里 return 会让程序行为变得诡异。

推荐写法 ：

public int cleanReturn() {
    int result = -1; // 默认值或错误码
    Connection conn = null;
    try {
        conn = getConnection();
        // ... 使用 conn 操作 ...
        result = 1; // 操作成功
        return result; // 在 try 中返回
    } catch (SQLException e) {
        System.err.println("Database error: " + e.getMessage());
        result = -2; // 数据库错误码
        return result; // 在 catch 中返回
    } finally {
        // 只做清理工作
        if (conn != null) {
            try {
                conn.close();
                System.out.println("Connection closed.");
            } catch (SQLException e) {
                System.err.println("Failed to close connection: " + e.getMessage());
            }
        }
        // 不要在 finally 中 return
    }
}

finally 专注于它的本职工作——资源清理，让返回值逻辑在 try 和 catch 中清晰地处理。

结尾

return 虽小，五脏俱全。

一切的目的都是让代码更加优雅，逻辑更加清晰。

这些并非什么高深的理论，更多的是在日常写代码时，对可读性、简洁性和健壮性的追求。

到此这篇关于11个值得借鉴的Java return写法分享的文章就介绍到这了,更多相关Java return写法内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！