视频先行
这是一篇视频形式的共享，假设你便利看，可以直接去看视频：
- 哔哩哔哩：这儿
- 抖音：这儿
- YouTube：这儿
下面是视频内容的脚本案牍原稿共享。
视频案牍原稿
许多从 Java 转到 Kotlin 的人都会有一个疑问：为什么 Kotlin 没有沿袭 Java 的 void 关键字，而要引进这个叫 Unit 的新东西？
// Java
public void sayHello() {
System.out.println("Hello!");
}
// Kotlin
fun sayHello(): Unit {
println("Hello!")
}
不过这个问题一般也不会保持良久，因为就算你不明白，好像……也不影响写代码。
直到这两年，我们发现 Compose 的官方示例代码里竟然有把 Unit 填到函数参数里的状况：
LaunchedEffect(Unit) {
xxxx
xxxxxx
xxx
}
我们才觉得：「啊？还能这么写？」
Unit 的实质
我们好，我是扔物线朱凯。
今日来讲一讲 Unit 这个特别的类型。
我们在刚学 Kotlin 的时分，就知道 Java 的 void 关键字在 Kotlin 里没有了，取而代之的是一个叫做 Unit 的东西：
// Java
public void sayHello() {
System.out.println("Hello!")
}
// Kotlin
fun sayHello(): Unit {
println("Hello!")
}
而这个 Unit，和 Java 的 void 其实是不相同的。比如 Unit 的回来值类型，我们是可以省掉掉不写的：
// Kotlin
fun sayHello() {
println("Hello!")
}
不过省掉只是语法上的便当，实践上 Kotlin 还是会把它了解成 Unit。
Unit 和 Java 的 void 真实的差异在于，void 是真的表示什么都不回来，而 Kotlin 的 Unit 却是一个真实存在的类型：
public object Unit {
override fun toString() = "kotlin.Unit"
}
它是一个 object，也就是 Kotlin 里的单例类型或许说单例方针。当一个函数的回来值类型是 Unit 的时分，它是需求回来一个 Unit 类型的方针的：
// Kotlin
fun sayHello() {
println("Hello!")
return Unit
}
只不过因为它是个 object ，所以唯一能回来的值就是 Unit 本身。
另外，这一行 return 我们也可以省掉不写：
// Kotlin
fun sayHello() {
println("Hello!")
}
因为就像回来值类型相同，这一行 return，Kotlin 也会帮我们自动加上：
// Kotlin
fun sayHello(): Unit {
println("Hello!")
return Unit
}
这两个 Unit 是不相同的，上面的是 Unit 这个类型，下面的是 Unit 这个单例方针，它俩长得相同可是是不同的东西。留意了，这个并不是 Kotlin 给 Unit 的特权，而是 object 本来就有的语法特性。你假设有需求，也可以用相同的格式来运用其他单例方针，是不会报错的：
object Rengwuxian
fun getRengwuxian(): Rengwuxian {
return Rengwuxian
}
包含你也可以这样写：
val unit: Unit = Unit
也是相同的道理，等号左面是类型，等号右边是方针——当然这么写没什么实践效果啊，单例你就直接用就行了。
所以在结构上，Unit 并没有任何的特别之处，它就只是一个 Kotlin 的 object 算了。除了关于函数回来值类型和回来值的自动弥补之外，Kotlin 对它没有再施加任何的魔法了。它的特别之处，更多的是在于语义和用途的视点：它是个由官方规矩出来的、用于「什么也不回来」的场景的回来值类型。但这只是它被规矩的用法算了，而实质上它真就是个实实在在的类型。也就是在 Kotlin 里，并不存在真实没有回来值的函数，全部「没有回来值」的函数实质上的回来值类型都是 Unit，而回来值也都是 Unit 这个单例方针，这是 Unit 和 Java 的 void 在实质上的不同。
Unit 的价值地点
那么接下来的问题就是：这么做的含义在哪？
含义就在于，Unit 去掉了无回来值的函数的特别性，消除了有回来值和无回来值的函数的实质差异，这样许多事做起来就会更简略了。
例：有回来值的函数在重写时没有回来值
比如？
比如在 Java 里面，因为 void 并不是一种真实的类型，所以任何有回来值的方法在子类里的重写方法也都必须有回来值，而不能写成 void，不管你用不用泛型都是相同的：
public abstract class Maker {
public abstract Object make();
}
public class AppleMaker extends Maker {
// 合法
@Override
public Apple make() {
return new Apple();
}
}
public class NewWorldMaker extends Maker {
// 不合法
@Override
public void make() {
world.refresh();
}
}
public abstract class Maker<T> {
public abstract T make();
}
public class AppleMaker extends Maker<Apple> {
// 合法
Override
public Apple make() {
return new Apple();
}
}
public class NewWorldMaker extends Maker<void> {
// 不合法
Override
public void make() {
world.refresh();
}
}
你只能去写一行 return null 来手动完成接近于「什么都不回来」的效果：
public class NewWorldMaker extends Maker {
@Override
public Object make() {
world.refresh();
return null;
}
}
并且假设你用的是泛型，或许还需求用一个专门的虚伪类型来让效果抵达完美：
public class NewWorldMaker extends Maker<Void> {
@Override
public Void make() {
world.refresh();
return null;
}
}
Unit 是一种真实存在的类型，所以直接写就行了：
abstract class Maker {
abstract fun make(): Any
}
class AppleMaker : Maker() {
override fun make(): Apple {
return Apple()
}
}
class NewWorldMaker : Maker() {
override fun make() {
world.refresh()
}
}
abstract class Maker<T> {
abstract fun make(): T
}
class AppleMaker : Maker<Apple>() {
override fun make(): Apple {
return Apple()
}
}
class NewWorldMaker : Maker<Unit>() {
override fun make() {
world.refresh()
}
}
这就是 Unit 的去特别性——或许说通用性——所给我们带来的便当。
例：函数类型的函数参数
相同的，这种去特别性关于 Kotlin 的函数式编程也供给了便利。一个函数的函数类型的参数，在函数调用的时分填入的实参，只要符合声明里面的回来值类型，它是可以有回来值，也可以没有回来值的：
fun runTask(task: () -> Any) {
when (val result = task()) {
Unit -> println("result is Unit")
String -> println("result is a String: $result")
else -> println("result is an unknown type")
}
}
...
runTask { } // () -> Unit
runTask { "结束！" } // () -> String
runTask { 1 } // () -> Int
Java 不支持把方法作为方针来传递，所以我们无法跟 Java 做比照；但假设 Kotlin 不是像现在这样用了 Unit，而是照抄了 Java 的 void 关键字，我们就必定没方法这样写。
小结：去特别化
这就是我刚才所说的，关于无回来值的函数的「去特别化」，是 Unit 最核心的价值。它适当所以对 Java 的 void 进行了缺点的批改，让本来有的问题现在没有了。而关于实践开发，它的效果是归于润物细无声的，你不需求懂我说的这一大堆东西，也不影响你享受 Unit 的这些优点。
…………
那我出这期视频干嘛？
——开个打趣。了解各种魔法背后的实质，关于我们把握和正确地运用一门言语是很有必要的。
延伸：作为朴实的单例方针来运用
比如，知道 Unit 是什么之后，你就能了解为什么它能作为函数的参数去被运用。
Compose 里的协程函数 LaunchedEffect() 要求我们填入至少一个 key 参数，来让协程在界面状态变化时可以自动重启：
LaunchedEffect(key) {
xxxx
xxxxxx
xxx
}
而假设我们没有自动重启的需求，就可以在参数里填上一个 Unit：
LaunchedEffect(Unit) {
xxxx
xxxxxx
xxx
}
因为 Unit 是不变的，所以把它填进参数里，这个协程就不会自动重启了。这招用着十分便利，Compose 的官方示例里也有这样的代码。不过这个和 Unit 本身的定位已经无关了，而只是是在运用它「单例」的性质。实践上，你在括号里把它换成任何的常量，效果都是完全相同的，比如 true、比如 false、比如 1、比如 0、比如 你好，都是可以的。所以假设你什么时分想「随意拿个方针过来」，或许「随意拿个单例方针过来」，也可以运用 Unit，它和你自己创建一个 object 然后去运用，效果是相同的。
总结
好，这就是 Kotlin 的 Unit，希望这个视频可以协助你更好地了解和运用它。下期我会讲 Kotlin 里另一个特别的类型：Nothing。注重我，了解更多 Android 开发的常识和技能。我是扔物线，我欠好你比凹凸，我只助你成长。我们下期见！
