Kotlin Lambda语法错误修复

出现报错,解决一下:Bad return type in lambda expression: void cannot be converted to Unit这是代码:onKey(KeyCode.UP,()->warriorComponent.moveDirection(Dir.UP));
        onKey(KeyCode.DOWN,()->warriorComponent.moveDirection(Dir.DOWN));
        onKey(KeyCode.LEFT,()->warriorComponent.moveDirection(Dir.LEFT));
        onKey(KeyCode.RIGHT,()->warriorComponent.moveDirection(Dir.RIGHT));

好的，我现在需要解决用户遇到的这个错误：“Bad return type in lambda expression: void cannot be converted to Unit”。这个问题发生在他们的Kotlin代码，特别是当他们调用onKey函数并传递lambda表达式的时候。让我仔细分析一下。

首先，用户提供的代码是这样的：

onKey(KeyCode.UP,()->warriorComponent.moveDirection(Dir.UP));
onKey(KeyCode.DOWN,()->warriorComponent.moveDirection(Dir.DOWN));
// 其他类似行...

错误信息指出lambda表达式的返回类型有问题，void无法转换为Unit。这可能是因为在Java中，void对应的是Kotlin的Unit类型，但可能存在类型推断的问题。

接下来，我需要考虑Kotlin中lambda的返回类型。在Kotlin中，如果一个lambda没有显式的返回语句，那么它的返回类型是最后一个表达式的类型。例如，如果函数返回Unit，那么lambda会自动适应。但在这里，问题可能出在用户使用的是Java的接口或函数式接口，而Kotlin在转换时可能出现了类型不匹配。

例如，假设onKey函数的第二个参数期望的是一个返回Unit的lambda，而用户可能写了一个带有大括号的lambda，导致它被推断为返回Unit，但实际可能返回了void(Java的情况)，或者可能用户在某些情况下没有正确匹配返回类型。

另一个可能性是用户在使用Java中的函数式接口，比如Consumer或Runnable，而Kotlin的lambda可能在这里没有正确匹配。例如，如果onKey方法期望的是一个返回Unit的Kotlin函数类型，但用户可能传递了一个返回void的Java lambda，或者相反。

或者，可能用户在lambda中使用了表达式语法和大括号的错误组合。例如，当使用大括号时，如果最后一个表达式不是Unit类型，可能会出现问题。比如，如果warriorComponent.moveDirection方法返回的是void(即Unit)，但可能在某些情况下，lambda的结构导致编译器无法正确推断。

用户提供的代码的lambda写法是使用箭头函数，即 ()->，这在Kotlin中可能不正确。因为在Kotlin中，lambda的语法是使用大括号{}，而不是箭头->。正确的Kotlin lambda应该是没有箭头，参数放在前面，然后是箭头，然后是函数体。比如：{ -> ... }，但可能用户混淆了Java的lambda语法和Kotlin的。

例如，在Kotlin中，一个无参数的lambda应该写作{ warriorComponent.moveDirection(Dir.UP) }，而不是()->warriorComponent...。用户可能错误地使用了Java风格的lambda语法，导致编译器无法正确识别。

所以问题可能出在这里：在Kotlin中，lambda的语法是使用花括号{}，参数放在里面，然后是->，然后是表达式。如果lambda没有参数，可以写成{ ... }，而不是()-> ...。例如，正确的写法应该是onKey(KeyCode.UP, { warriorComponent.moveDirection(Dir.UP) })。或者，当函数作为最后一个参数时，可以放到括号外面，比如onKey(KeyCode.UP) { warriorComponent.moveDirection(Dir.UP) }。

另外，如果onKey函数的第二个参数是一个函数类型为 () -> Unit 的参数，那么在Kotlin中正确传递lambda应该是用花括号包裹，而不是使用箭头函数在参数列表中。用户可能误用了Java的语法，导致编译器认为返回类型不匹配。

例如，在Java中，lambda可能是写成() -> { ... }，但在Kotlin中应该使用花括号。而用户代码的写法是()->warriorComponent...，这可能在Kotlin中被解析为尝试返回一个函数类型，从而导致类型不匹配。

因此，解决方法是修改lambda的语法，使用正确的Kotlin格式。例如，将每个lambda参数用花括号包围，并且确保没有错误的箭头符号。或者，如果onKey函数接受一个函数类型参数，可能需要调整lambda的写法。

另一个可能性是，用户在使用某个框架或库，其中onKey方法期望的是定的函数类型，比如返回Unit，但用户可能在lambda中错误地返回了其他类型，或者没有正确返回。例如，如果moveDirection方法返回的是某个非Unit类型，但此时lambda应该返回Unit，这时候可能会报错。但根据错误信息，问题出在void无法转换为Unit，这可能说明在Java的上下文中，某个返回void的方法被当作返回Unit处理，但可能发生了冲突。

总结，可能的解决步骤：

1. 检查onKey函数的定义，确认第二个参数期望的函数类型。例如，是否是 () -> Unit。

2. 确保lambda的语法正确，使用花括号而不是箭头符号在参数列表中。

3. 修改代码的lambda表达式，用正确的Kotlin语法。

比如，将原来的：

onKey(KeyCode.UP,()->warriorComponent.moveDirection(Dir.UP));
修改为：
onKey(KeyCode.UP) { warriorComponent.moveDirection(Dir.UP) }
或者：
onKey(KeyCode.UP, { warriorComponent.moveDirection(Dir.UP) })

这取决于onKey函数的参数是否允许将lambda放在括号外。

另外，检查是否在Java和Kotlin混合编程时出现了类型不匹配的情况，比如onKey是Java方法，期望一个Runnable或某个函数式接口，而Kotlin的lambda可能没有正确匹配。

例如，如果onKey是一个Java方法，接受一个Runnable参数，那么在Kotlin中应该使用lambda表达式来匹配，例如：

onKey(KeyCode.UP, Runnable { warriorComponent.moveDirection(Dir.UP) })

或者，如果参数是Java的FunctionalInterface，可能需要显式转换。

不过，根据错误信息中的Unit和void的问题，更可能的是lambda的语法错误导致返回类型推断失败。所以将lambda改为正确的Kotlin语法应该可以解决问题。

这个错误是由于在Kotlin中错误地使用了Java风格的Lambda语法导致的。以下是修复步骤：

1. 修正Lambda语法：使用Kotlin的花括号{}包裹Lambda表达式，而不是Java的箭头->语法。
2. 移除参数列表的空括号：无参数的Lambda在Kotlin中不需要()。

修改后的代码：

onKey(KeyCode.UP) { warriorComponent.moveDirection(Dir.UP) }
onKey(KeyCode.DOWN) { warriorComponent.moveDirection(Dir.DOWN) }
onKey(KeyCode.LEFT) { warriorComponent.moveDirection(Dir.LEFT) }
onKey(KeyCode.RIGHT) { warriorComponent.moveDirection(Dir.RIGHT) }

解释：

• Kotlin的Lambda表达式应该用花括号{}包裹
• 当Lambda作为最后一个参数时，可以放在括号外
• 无参数的Lambda直接以{ 代码 }形式编写，不需要->
• warriorComponent.moveDirection()方法返回的Unit类型(Kotlin的void)会与函数参数要求的返回类型正确匹配

这样修改后，Lambda表达式将正确返回Unit类型，错误即可消除。

我这个是JAVA21:Bad return type in lambda expression: void cannot be converted to Unit,都不行:onKey(KeyCode.UP,{warriorComponent.moveDirection(Dir.UP)});

嗯，用户现在提到他们使用的是Java 21，之前的建议是针对Kotlin的，但现在错误依然存在。这说明用户可能混淆了Kotlin和Java的语法，或者在Java环境下遇到了类似的问题。我需要仔细分析用户提供的代码和错误信息。

首先，错误信息是“Bad return type in lambda expression: void cannot be converted to Unit”。Unit是Kotlin中的类型，对应Java的void。如果在Java中出现这样的错误，可能意味着用户误用了Kotlin特有的函数式接口，或者在Java中错误地处理了返回类型。但Java的Lambda表达式返回void应该不会有问题，除非目标接口需要返回某个类型，而用户的方法返回void，导致类型不匹配。

查看用户提供的代码：onKey(KeyCode.UP, { warriorComponent.moveDirection(Dir.UP) });。这里使用了Java的Lambda语法，但大括号包裹可能有问题。Java中Lambda的正确语法是参数 -> 表达式，如果使用代码块，则需要用大括号，但用户的情况是否需要？

可能的问题在于onKey方法的第二个参数期望的是一个返回特定类型(比如Unit)的函数式接口，但用户提供的Lambda返回void。例如，如果onKey方法期望的是Kotlin的() -> Unit类型，而用户在Java中使用Lambda，返回void，就会出现类型不匹配，因为Unit在Kotlin中是实际存在的类型，而Java的void无法自动转换。

或者，用户可能在Java中调用了一个Kotlin函数，该函数期望一个返回Unit的Lambda。Kotlin的Unit在Java中对应为void，但Kotlin的函数式接口可能需要返回Unit，而Java的Lambda返回void，导致不兼容。

解决方案可能包括：

1. 在Java中使用特定的Kotlin函数式接口，例如使用Kotlin的Function类型，并显式返回Unit.INSTANCE。

2. 检查onKey方法的参数类型，确认第二个参数期望的函数式接口类型，并调整Lambda表达式以匹配返回类型。

3. 如果可能，将代码迁移到Kotlin，避免混合使用Java和Kotlin导致的问题。

用户当前的Java代码可能应该正确使用Java的函数式接口，但如果调用了Kotlin库，可能需要特殊处理返回类型。例如，在Java中返回Unit.INSTANCE，或者使用Kotlin的辅助函数。

需要进一步确认用户是否在Java中调用了Kotlin的函数，以及onKey方法的参数类型。如果onKey是Kotlin函数，接收一个() -> Unit类型的Lambda，那么在Java中需要返回Unit，例如：

onKey(KeyCode.UP, () -> {
warriorComponent.moveDirection(Dir.UP);
return Unit.INSTANCE;
});

这样显式返回Unit.INSTANCE可以解决类型不匹配的问题。

总结：用户可能在Java中调用Kotlin函数，导致返回类型不匹配，需要显式返回Unit.INSTANCE或在Kotlin中处理。

在 Java 21 中出现 Bad return type in lambda expression: void cannot be converted to Unit 错误，通常是因为在调用 Kotlin 函数时混用了 Java 的 Lambda 语法，而 Kotlin 的 Unit 类型与 Java 的 void 不完全兼容。以下是详细分析和修复方法：

---

问题原因

• Kotlin 的 Unit 类型：在 Kotlin 中，Unit 是一个实际存在的类型(类似于 Java 的 Void)，而 void 在 Java 中不是一个类型。
• 函数式接口不匹配：如果你在 Java 中调用一个 Kotlin 函数，且该函数期望一个返回 Unit 的 Lambda(如 () -> Unit)，Java 的 Lambda 表达式默认返回 void，会导致类型不匹配。

---

修复方法

1. 如果 onKey 是 Kotlin 函数

假设 onKey 是 Kotlin 函数且定义为：

fun onKey(key: KeyCode, action: () -> Unit) { ... }

在 Java 中调用时，需要显式返回 Unit：

onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return Unit.INSTANCE; // 显式返回 Unit
});

---

2. 如果 onKey 是 Java 函数

如果 onKey 是 Java 方法，且第二个参数是 Runnable 或类似的函数式接口：

void onKey(KeyCode key, Runnable action) { ... }

直接使用 Lambda 即可(无需返回任何值)：

onKey(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

---

3. 混合 Java 和 Kotlin 的通用方案

如果问题源于混合 Java 和 Kotlin 代码，可以通过以下方式统一类型：

• 在 Kotlin 中定义扩展函数(推荐)：

// Kotlin 辅助函数
fun onKeyJavaStyle(key: KeyCode, action: Runnable) {
    onKey(key) { action.run() }
}

在 Java 中调用：

onKeyJavaStyle(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

---

完整修复代码

// 如果 onKey 是 Kotlin 函数，需要返回 Unit
onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return Unit.INSTANCE;
});

// 如果 onKey 是 Java 函数(如接受 Runnable)
onKey(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

---

关键点

• 区分 Java 和 Kotlin 的类型系统：Kotlin 的 Unit 需要显式返回 Unit.INSTANCE，而 Java 的 void 无需返回值。
• 检查函数签名：确认 onKey 的参数类型是 Kotlin 的 () -> Unit 还是 Java 的 Runnable/Consumer。

通过上述方法，可以解决 void cannot be converted to Unit 的类型兼容性问题。

\src\main\java\com\alatus\FXGL\SpriteGame.java:30:60 java: 不兼容的类型: lambda 表达式中的返回类型错误 void无法转换为kotlin.Unit

嗯，用户现在遇到了一个Java和Kotlin混合编程时常见的类型不兼容问题。错误信息是“void无法转换为kotlin.Unit”，出现在Java调用Kotlin函数时使用的Lambda表达式中。用户之前已经尝试过一些方法，但问题依然存在，现在情绪比较激动，需要冷静分析。

首先，用户提到他们使用的是Java 17，而错误是在调用Kotlin函数时出现的。错误明确指出返回类型不兼容，Java的void无法转换为Kotlin的Unit。这说明用户可能在Java代码调用了Kotlin的函数，该函数期望一个返回Unit的Lambda，但Java的Lambda默认返回void，导致类型不匹配。

回顾之前的对话，用户可能已经尝试过使用花括号或者显式返回Unit.INSTANCE，但可能由于某些原因没有成功。现在用户提供的代码是：

onKey(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

这里的问题在于，当Java的Lambda作为参数传递给Kotlin函数，而该函数期望一个返回Unit的Lambda时，Java的Lambda默认返回void，而Kotlin需要Unit。这时候需要强制Java的Lambda返回Unit类型，但Java中的void方法无法返回值，因此需要特殊处理。

可能的解决方案是让Lambda表达式显式返回Unit.INSTANCE，这样即使方法本身是void，也会强制Lambda返回Unit。例如：

onKey(KeyCode.UP, () -> {
warriorComponent.moveDirection(Dir.UP);
return Unit.INSTANCE;
});

但是用户可能已经尝试过这种方法，仍然报错。这时候需要检查onKey函数的定义，确认其参数类型是否为Kotlin的函数类型，如() -> Unit，或者是Java的函数式接口，如Runnable。如果是前者，那么必须返回Unit；如果是后者，可能不需要。

另外，可能用户的环境配置有问题，比如Kotlin运行时库版本不兼容，或者项目配置有误，导致Unit类无法正确引用。需要检查import语句是否正确，是否导入了kotlin.Unit。

还有一种可能是用户混淆了Kotlin和Java的Lambda语法，例如在Java中应该使用Runnable而不是Kotlin的函数类型，这时候需要调整函数定义或者在Java中使用适配器方法。

总结下来，正确的解决步骤应该是：

1. 确认onKey函数的定义，确定其期望的参数类型是Kotlin的() -> Unit还是Java的Runnable等。

2. 如果onKey是Kotlin函数，使用显式返回Unit.INSTANCE的方式。

3. 如果onKey是Java函数，可能需要调整参数类型。

4. 检查项目配置和导入，确保Unit类正确可用。

5. 考虑在Kotlin中创建适配器函数，以便在Java中更方便地调用。

用户现在可能因为多次尝试未果而感到沮丧，需要耐心引导，逐步排查可能的问题点，并提供清晰的解决方案示例。

以下是针对 Java 17 调用 Kotlin 函数时出现 void 无法转换为 kotlin.Unit 的终极解决方案：

---

问题根源

• Kotlin 的 Unit：Kotlin 中 Unit 是一个实际存在的单例对象(类似 Void + void 的混合体)，而 Java 的 Lambda 默认返回 void。
• 跨语言类型不匹配：当 Java 代码调用 Kotlin 函数时，如果该 Kotlin 函数参数类型是 () -> Unit，Java 的 Lambda 必须显式返回 Unit.INSTANCE，否则类型不兼容。

---

直接修复代码

import kotlin.Unit; // 确保导入 Unit

onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return Unit.INSTANCE; // 强制返回 Unit
});

---

分步解释

1. 导入kotlin.Unit：

import kotlin.Unit;

确保 Kotlin 标准库已正确引入项目依赖。

1. 显式返回Unit.INSTANCE：

onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP); // 执行实际逻辑
    return Unit.INSTANCE; // 强制 Lambda 返回 Unit 类型
});

• 即使 moveDirection 方法返回 void，也必须通过 return Unit.INSTANCE 让 Lambda 的返回类型匹配 Kotlin 的 Unit。

---

根治方案(推荐)

如果 onKey 是 Kotlin 函数，可以在 Kotlin 中定义一个 Java 友好的包装函数，避免在 Java 中手动处理 Unit：

1. 在 Kotlin 中定义扩展函数：

// 文件：KotlinUtils.kt
fun onKeyJava(key: KeyCode, action: Runnable) {
    onKey(key) { action.run() } // 自动转换 Runnable 为 Kotlin Unit
}

1. 在 Java 中调用：

onKeyJava(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

• 现在 Lambda 直接匹配 Java 的 Runnable 接口，无需处理 Unit。

---

验证依赖配置

确保项目的 pom.xml 或 build.gradle 中包含 Kotlin 标准库：

<!-- Maven 示例 -->
<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib</artifactId>
    <version>1.9.0</version> <!-- 使用最新版本 -->
</dependency>

---

终极总结

场景	解决方案
直接 Java 调用 Kotlin 函数	Lambda 末尾显式 return Unit.INSTANCE
频繁跨语言调用	在 Kotlin 中定义 Runnable 包装函数
依赖问题	检查 kotlin-stdlib 是否引入

按上述方法操作后，void 和 Unit 的类型冲突将彻底解决。

我看了一下源码接口,貌似真是kotlin:public fun onKey(key: javafx.scene.input.KeyCode, action: () -> kotlin.Unit): kotlin.Unit { /* compiled code */ } public fun onKey(key: javafx.scene.input.KeyCode, actionName: kotlin.String, action: () -> kotlin.Unit): kotlin.Unit {

好的，我现在要解决用户的问题。用户在使用Java调用Kotlin函数时遇到了类型不匹配的错误，错误信息是“Bad return type in lambda expression: void cannot be converted to Unit”。之前用户已经尝试了一些解决方案，但问题依然存在。现在用户查看了Kotlin源码，确认onKey函数的参数确实是一个返回Unit的Lambda表达式。用户可能是在Java代码调用这个Kotlin函数，但Java的Lambda默认返回void，导致类型不兼容。

首先，我需要确认用户的问题环境。用户提到使用的是Java 17，并且调用的onKey函数是Kotlin编写的，参数是一个返回Unit的Lambda。Kotlin的Unit对应Java中的Void，但处理方式不同。在Java中，Lambda表达式如果没有返回值，默认是void，而Kotlin期望的是一个返回Unit的Lambda，因此需要显式返回Unit.INSTANCE。

接下来，用户之前尝试的解决方案是在Lambda中添加return Unit.INSTANCE，但可能没有正确导入kotlin.Unit类，或者构建配置中缺少Kotlin标准库的依赖。这时候需要检查用户的依赖配置，确保项目中有正确的Kotlin库引入。

另外，用户可能对在Java中频繁处理Unit感到繁琐，所以可以考虑在Kotlin中创建一个适配器函数，将Java的Runnable转换为Kotlin的Unit，这样在Java中调用时就不需要每次都返回Unit.INSTANCE了。这种方法能简化Java端的代码，避免重复劳动。

还需要考虑用户是否了解如何在Kotlin中编写这样的适配器函数，可能需要给出具体的代码示例，并指导用户如何在Java中调用这个适配后的方法。同时，要确保用户的项目配置正确，比如构建工具(Maven或Gradle)中包含了Kotlin的依赖。

此外，用户可能在之前的尝试中遇到了导入问题，比如没有正确导入kotlin.Unit，或者在Lambda中遗漏了return语句的结构。需要详细说明每个步骤的注意事项，比如在Java中必须显式返回Unit.INSTANCE，并且Lambda体需要使用大括号包裹，即使只有一行代码。

最后，用户可能对Kotlin和Java之间的互操作不太熟悉，需要解释清楚两者在函数式接口和返回类型处理上的差异，帮助用户理解为什么会出现这个错误，以及如何通过适配器模式或显式返回来解决。

根据你提供的 Kotlin 函数签名，这是一个典型的 Kotlin-Java 互操作问题。以下是 终极解决方案，分步骤彻底解决 void 和 Unit 的类型冲突：

---

1. 问题精准定位

Kotlin 函数签名：

public fun onKey(
    key: KeyCode, 
    action: () -> Unit  // 这里要求 Lambda 必须返回 Unit 类型
): Unit

• 关键点：Kotlin 的 Unit 是一个真实存在的对象(类似 void 的包装类型)，而 Java 的 void 方法不会返回任何值。
• 错误本质：Java 的 Lambda () -> { ... } 默认返回 void，无法自动转换为 Kotlin 的 Unit。

---

2. 直接修复代码(Java 端适配)

在 Java 中调用时，必须显式返回 Unit.INSTANCE：

import kotlin.Unit; // 必须导入 Unit

onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return Unit.INSTANCE; // 强制返回 Unit 对象
});

注意事项：

1. 依赖检查：确保项目中已正确引入 Kotlin 标准库(如 kotlin-stdlib)。
2. Lambda 语法：必须用 {} 包裹多行代码，单行也建议显式写 return。
3. 静态导入优化(可选)：

import static kotlin.Unit.INSTANCE;

onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return INSTANCE; // 简化为 INSTANCE
});

---

3. 根治方案(Kotlin 端适配)

如果频繁在 Java 中调用此函数，建议在 Kotlin 中定义一个 Java 友好版 的 onKey 函数，隐藏 Unit 的细节：

步骤 1：在 Kotlin 中扩展函数

// 文件：KeyExtensions.kt
fun onKeyJava(key: KeyCode, action: Runnable) {
    onKey(key) { action.run() } // 自动将 Runnable 转换为 Unit
}

步骤 2：在 Java 中直接调用

// 无需处理 Unit，直接使用 Java 的 Runnable
onKeyJava(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

原理：

• Kotlin 的 Runnable 对应 () -> Unit，action.run() 执行后会自动返回 Unit。
• Java 调用时无需关心 Unit，直接匹配 Runnable 接口。

---

4. 验证依赖配置

确保项目的构建文件(如 Maven 或 Gradle)中包含 Kotlin 标准库：

Maven 示例：

<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib</artifactId>
    <version>1.9.0</version> <!-- 使用最新版本 -->
</dependency>

Gradle 示例：

implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.0"

---

5. 两种方案对比

方案	优点	缺点
Java 端显式返回 Unit.INSTANCE	直接修改调用代码，无需 Kotlin 改动	代码冗余，每个 Lambda 都要写 return
Kotlin 端扩展函数	Java 调用简洁，一劳永逸	需要 Kotlin 代码的修改权限

---

6. 错误复现与根治验证

错误写法(Java)：

onKey(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

• 结果：编译错误，因为 Lambda 返回 void，而 Kotlin 需要 Unit。

正确写法：

// 方案1：显式返回 Unit
onKey(KeyCode.UP, () -> {
    warriorComponent.moveDirection(Dir.UP);
    return Unit.INSTANCE;
});

// 方案2：调用 Kotlin 扩展的 Java 友好函数
onKeyJava(KeyCode.UP, () -> warriorComponent.moveDirection(Dir.UP));

---

最终结论

• 临时修复：在 Java 的 Lambda 中显式返回 Unit.INSTANCE。
• 永久根治：在 Kotlin 中封装一个适配 Runnable 的扩展函数，让 Java 彻底摆脱 Unit。

按上述任一方法操作后，void cannot be converted to Unit 错误将彻底消失。