133. Java 泛型 - 目标类型与方法参数：重载解析与类型推导133. Java 泛型 - 目标类型与方法参数：重

133. Java 泛型 - 目标类型与方法参数：重载解析与类型推导

在 Java 中，目标类型（Target Type） 让编译器能够根据方法参数的类型来推断 Lambda 表达式的类型。当一个方法被重载（Overloading），且参数类型可以是不同的函数式接口时，Java 编译器会通过“重载解析”和“类型参数推理”来决定调用哪个方法。

1. 目标类型如何影响方法参数？

Java 编译器使用两种机制来决定 Lambda 表达式的类型： ✅ 重载解析（Overload Resolution） ✅ 类型参数推理（Type Inference）

2. 目标类型在方法重载中的应用

📌 例子：Runnable 与 Callable

Java 提供了两个常见的函数式接口：

public interface Runnable {
    void run();
}

public interface Callable<V> {
    V call();
}

🔹 Runnable.run() 没有返回值（void）。 🔹 Callable<V>.call() 有返回值，返回类型为 V。

✅ 示例 1：方法重载

我们定义了两个重载方法 invoke：

public class TargetTypeDemo {
    void invoke(Runnable r) {
        r.run();
    }

    <T> T invoke(Callable<T> c) {
        return c.call();
    }
}

如果我们调用：

String s = invoke(() -> "done");

🧐 问题：invoke(() -> "done") 调用的是哪个方法？

3. Lambda 表达式的目标类型推断

编译器需要确定 () -> "done" 是 Runnable 还是 Callable<T>？

❌ Runnable 版本（不匹配）

void invoke(Runnable r) {
    r.run(); // 运行时不会返回任何值
}

Runnable.run() 没有返回值，而 invoke(() -> "done") 期望返回 String，所以 Runnable 不匹配。

✅ Callable<T> 版本（匹配）

<T> T invoke(Callable<T> c) {
    return c.call(); // `call()` 返回 T（在这里是 String）
}

Callable<String> 期望 call() 方法有返回值，而 () -> "done" 返回 "done"，因此它符合 Callable<String> 类型。
最终调用 invoke(Callable<T>) 版本，返回 "done"。

4. 方法调用时 Lambda 表达式的目标类型

让我们看一些不同的调用方式，看看 Lambda 如何推断目标类型👇

✅ 示例 2：明确调用 `Runnable` 版本

invoke((Runnable) () -> System.out.println("Running"));

🔍 解析

(Runnable) () -> System.out.println("Running") 强制转换为 Runnable，所以 invoke(Runnable r) 被调用。
run() 方法不返回值，因此不会返回任何内容。

✅ 示例 3：明确调用 `Callable<T>` 版本

String result = invoke((Callable<String>) () -> "Task completed");
System.out.println(result); // 输出: Task completed

🔍 解析

(Callable<String>) () -> "Task completed" 强制转换为 Callable<String>，调用 invoke(Callable<T>) 版本。
call() 返回 "Task completed"，并赋值给 result。

✅ 示例 4：传递 Lambda 表达式

invoke(() -> {
    System.out.println("Hello");
});

🔍 解析

invoke(Runnable r) 被调用，因为 System.out.println("Hello") 没有返回值，符合 Runnable.run() 的签名。

5. 目标类型的局限性

🚨 ⚠️ 编译器可能无法推断 Lambda 的目标类型！

Object obj = () -> "Hello"; // ❌ 编译错误

🔍 解析

Object 不是函数式接口，因此 无法推断 Lambda 的类型，会导致编译错误。

👉 解决方案：显式声明类型

Callable<String> callable = () -> "Hello"; // ✅ 正确
Object obj = (Callable<String>) (() -> "Hello"); // ✅ 正确

6. 结论

✅ Java 编译器利用目标类型来决定 Lambda 表达式的具体类型。 ✅ 重载解析（Overload Resolution）会选择返回值匹配的函数式接口。 ✅ Lambda 需要明确的目标类型，否则编译器可能无法推断类型。 ✅ 使用显式类型转换（Casting）可以强制指定目标类型。

🎯 目标类型 + Lambda 让 Java 泛型推导更智能，减少了不必要的类型声明，使代码更简洁！🚀

133. Java 泛型 - 目标类型与方法参数：重载解析与类型推导