return 是 Java 中的一个关键字,它主要有两大核心功能：

1. 从方法中退出：立即终止当前方法的执行,并将程序控制权交还给调用该方法的代码。
2. 返回值：将一个值从方法中传递出去,这个值的数据类型必须与方法声明的返回类型相匹配。

下面我们通过不同的场景来深入理解 return 的用法。

有返回值的方法（return 用于返回数据）

当你在方法声明时使用了除 void 之外的任何数据类型（如 int, String, Object 等），就意味着这个方法必须返回一个相应类型的值。return 的第二个功能——返回值——就变得至关重要。

语法

return value; // value 必须与方法声明的返回类型兼容

示例

public class ReturnValueExample {
    // 1. 返回一个整数
    public int add(int a, int b) {
        int sum = a + b;
        return sum; // 返回计算结果
    }
    // 2. 返回一个字符串
    public String getGreeting(String name) {
        return "Hello, " + name + "!";
    }
    // 3. 返回一个对象
    public Person createPerson(String name, int age) {
        Person p = new Person(name, age);
        return p; // 返回新创建的 Person 对象
    }
    public static void main(String[] args) {
        ReturnValueExample example = new ReturnValueExample();
        // 调用 add 方法并接收返回值
        int result = example.add(10, 20);
        System.out.println("10 + 20 = " + result); // 输出: 10 + 20 = 30
        // 调用 getGreeting 方法
        String greeting = example.getGreeting("Alice");
        System.out.println(greeting); // 输出: Hello, Alice!
        // 调用 createPerson 方法
        Person person = example.createPerson("Bob", 30);
        System.out.println("Created person: " + person.getName()); // 输出: Created person: Bob
    }
}
// 假设的 Person 类
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
}

关键点：

• 必须返回：如果一个方法声明了返回类型（非 void），那么在所有可能的执行路径上都必须有 return 语句，否则,编译器会报错。
• 类型匹配：return 的值必须是方法返回类型本身或是其子类（对于对象类型）。

// 错误示例：编译器会报错，因为不是所有路径都有返回值
public int checkNumber(int number) {
    if (number > 0) {
        return 1;
    }
    // number <= 0，这里没有返回值，编译不通过
}

无返回值的方法（void 方法）

当方法声明为 void 时，它只执行一系列操作，不返回任何值，在这种情况下，return 的第一个功能——提前退出方法——就派上了用场。

语法

return; // 不返回任何值，仅用于跳出方法

示例

最常见的用法是在满足某个条件时提前终止方法执行。

public class VoidMethodExample {
    // 打印指定范围内的偶数
    public void printEvenNumbers(int start, int end) {
        // 如果起始值大于结束值，直接返回，不做任何事
        if (start > end) {
            System.out.println("Invalid range: start is greater than end.");
            return; // 提前退出方法
        }
        System.out.println("Even numbers between " + start + " and " + end + ":");
        for (int i = start; i <= end; i++) {
            if (i % 2 == 0) {
                System.out.print(i + " ");
            }
        }
        System.out.println(); // 换行
    }
    // 模拟登录方法
    public void login(String username, String password) {
        if (username == null || password == null) {
            System.out.println("Login failed: Username or password cannot be null.");
            return; // 参数无效，直接返回
        }
        // ... 这里是实际的登录逻辑 ...
        if (username.equals("admin") && password.equals("123456")) {
            System.out.println("Login successful! Welcome, " + username);
        } else {
            System.out.println("Login failed: Invalid username or password.");
        }
    }
    public static void main(String[] args) {
        VoidMethodExample example = new VoidMethodExample();
        example.printEvenNumbers(1, 10);
        // 输出:
        // Even numbers between 1 and 10:
        // 2 4 6 8 10
        example.printEvenNumbers(20, 5);
        // 输出:
        // Invalid range: start is greater than end.
        example.login("admin", "123456"); // 登录成功
        example.login("user", "wrong");    // 登录失败
        example.login(null, "password");   // 登录失败（参数无效）
    }
}

关键点：

• 非必需：在 void 方法中，return 语句是可选的，如果方法执行到末尾,它会自动返回。
• 用于控制流程：return 主要用于在满足特定条件时，避免执行后续不必要的代码,使逻辑更清晰。

在 try-catch-finally 块中的 return

这是一个比较特殊且容易混淆的情况，当 return 语句出现在 try 或 catch 块中时，finally 块的执行规则如下：

无论 try 或 catch 块中是否有 return，finally 块都会在方法真正返回之前执行。

示例 1：finally 中没有 return

public class FinallyReturnExample {
    public static int testFinally() {
        try {
            System.out.println("In try block");
            return 1; // 准备返回 1
        } finally {
            System.out.println("In finally block");
            // 这里没有 return，所以不会改变要返回的值
        }
        // 这行代码永远不会执行
    }
    public static void main(String[] args) {
        int result = testFinally();
        System.out.println("Result: " + result);
    }
}

输出结果：

In try block
In finally block
Result: 1

分析：

1. try 块中的 return 1 被执行，方法准备返回值 1。
2. 在返回之前，必须执行 finally 块。
3. finally 块执行完毕。
4. 方法最终返回 1。

示例 2：finally 中有 return（覆盖情况）

finally 块中也包含一个 return 语句，它将会覆盖 try 或 catch 块中的 return 值。

public class FinallyReturnOverrideExample {
    public static int testFinallyOverride() {
        try {
            System.out.println("In try block");
            return 1; // 准备返回 1
        } finally {
            System.out.println("In finally block");
            return 2; // finally 中的 return 覆盖了 try 中的 return
        }
    }
    public static void main(String[] args) {
        int result = testFinallyOverride();
        System.out.println("Result: " + result);
    }
}

输出结果：

In try block
In finally block
Result: 2

分析：

1. try 块中的 return 1 被执行，方法准备返回值 1。
2. 在返回之前，必须执行 finally 块。
3. finally 块执行，并执行了自己的 return 2。
4. 方法的返回值被更改为 2,并立即返回。
5. try 块中原来的 return 1 被完全丢弃。

最佳实践： 通常不建议在 finally 块中使用 return 语句，因为它会隐藏原始的返回值或异常，使代码难以理解和调试。finally 块最适合用于执行“清理”操作，如关闭文件、释放数据库连接等。

掌握 return 的用法是编写清晰、健壮的 Java 代码的基础，记住它的两个核心功能，并特别注意它在 finally 块中的特殊行为,就能避免很多常见的错误。