Kotlin 中的 data class
在使用 java 的时候，我们经常会重写类的 equals 、hashCode 和 toString 方法。这些方法往往都是模板化的。在 kotlin 中提供了更为简便的方法让我们使用一行代码搞定这些工作。这就是 data class。
// 定义一个 Person 类
data class Person(val name: String, val age: Int) {
}
写好上面的代码之后，Person 类中的上述几个方法的重写就由 kotlin 帮我们自动完成了。运行下面的代码
fun main() {
val p1 = Person("Jack", 24)
val p2 = Person("Jack", 24)
val p3 = Person("Jack", 32)
val p4 = Person("Rose", 31)
println(p1 == p2)
println(p1 === p2)
println(p1 == p3)
println("""
p1 hashCode = ${p1.hashCode()}
p2 hashCode = ${p2.hashCode()}
p3 hashCode = ${p3.hashCode()}
p4 hashCode = ${p4.hashCode()}
""".trimIndent())
println("p1 = $p1")
}
结果如下：
true
false
false
p1 hashCode = 71328761
p2 hashCode = 71328761
p3 hashCode = 71328769
p4 hashCode = 79149200
p1 = Person(name=Jack, age=24)
可以看到equals 、hashCode 和 toString 方法可以直接调用，并且已经被覆写了。
data class 究竟做了什么？
data class 是如何做到上述实现的呢？查看 Person 类的字节码反编译得到的 java 代码，如下
public final class Person {
@NotNull
private final String name;
private final int age;
@NotNull
public final String getName() {
return this.name;
}
public final int getAge() {
return this.age;
}
public Person(@NotNull String name, int age) {
Intrinsics.checkParameterIsNotNull(name, "name");
super();
this.name = name;
this.age = age;
}
@NotNull
public final String component1() {
return this.name;
}
public final int component2() {
return this.age;
}
@NotNull
public final Person copy(@NotNull String name, int age) {
Intrinsics.checkParameterIsNotNull(name, "name");
return new Person(name, age);
}
// $FF: synthetic method
public static Person copy$default(Person var0, String var1, int var2, int var3, Object var4) {
if ((var3 & 1) != 0) {
var1 = var0.name;
}
if ((var3 & 2) != 0) {
var2 = var0.age;
}
return var0.copy(var1, var2);
}
@NotNull
public String toString() {
return "Person(name=" + this.name + ", age=" + this.age + ")";
}
public int hashCode() {
String var10000 = this.name;
return (var10000 != null ? var10000.hashCode() : 0) * 31 + this.age;
}
public boolean equals(@Nullable Object var1) {
if (this != var1) {
if (var1 instanceof Person) {
Person var2 = (Person)var1;
if (Intrinsics.areEqual(this.name, var2.name) && this.age == var2.age) {
return true;
}
}
return false;
} else {
return true;
}
}
}
从上面可以一目了然地看见 kotlin 是如何构造 data class 的。由于我定义的成员变量是 val 不可变类型的，所以没有 Getter 和 Setter。
-
对于
equals方法，对于var1, 如果它的地址和自己不同，那么先检查其是否是Person类型 ，如果是，则逐个对比每个成员变量是否相等。这里用到的Intrinsics.areEqual(Object o1, Object o2)定义如下：public static boolean areEqual(Object first, Object second) { return first == null ? second == null : first.equals(second); }最终调用了被比较对象的
equals方法。 对于 Int 类型的成员变量age, 直接使用==比较。这是覆写一个类的
equals方法的常规写法。 hashCode和toString方法也是我们常规覆写的套路。-
提供了
component1和component2两个方法来获取成员变量。这两个方法可以用来做解构声明。如下：val (name, age) = Person("Rose", 43) println("$name, $age") // (name, age) 就是解构声明，name 对应 component1 , age 对应 component2 -
提供了
copy方法构造一个Person对象。有 //default` 方法是给 kotlin 编译器调用的，我们用不到。
注意 copy 是浅拷贝，且参数需要在 primary constructor 里面才会拷贝如果我们只想要
age不同的Person, 可以这样写val newPerson = p1.copy(age = 30)编译器编译到这句代码时，会帮我们调用
copy$default来构造一个name值和 p1 一样的newPerson对象 。
总之， data class 就是用常规套路来生成一个已经覆写好上述方法的类。
如果 Person 类不需要自动生成 age ，只需要把 age 从主构造函数中拿出，放到类体中就可以。如下
data class Person(val name： String) {
val age: Int = 0
}
Kotlin 中的 sealed class
- 枚举不支持泛型，数据不灵活
-
枚举限制每个类型只允许有一个实例
例
enum class Color(val value: Int) {
Red(1)
}
fun main(args: Array<String>) {
val red1 = Color.Red
val red2 = Color.Red
println("${red1 == red2}") // true
}
最后输出结果
red1 == red2 : true
无论 Color.Red 有多少个对象，最终他们的实例都是一个，每个枚举常量仅作为一个实例存在，而一个密封类的子类可以有多个包含状态的实例，这既是枚举的局限性也是枚举的优点。
sealed class 是一种同时拥有枚举类 enum 和 普通类 class 特性的类，叫做密封类。使用起来很简单，如下
sealed class Result
class Success(val code: Int) : Result()
class Exception(val code: Int, val message: String) : Result()
在同一个 kotlin 文件中声明三个类。首先声明 sealed class 类 Result, 然后定义出两个子类 Success, Exception 继承自 Result。注意，密封类及其子类必须声明在同一个 kotlin 文件中。
这是一个非常常见的场景。比如对于网络请求的结果 Result ， 往往只有两种类型，成功 Success 或者是失败 Exception 。使用普通的类不能把限制关系表达出来，使用枚举类则无法灵活地自定义需要的类的内容。这时候，sealed class 就派上用场了。比如在处理结果 Result 的时候:
fun handleResult(result: Result): String{
return when(result) {
is Success -> {
"success"
}
is Exception -> {
"exception"
}
}
}
这样，对于 handleResult 的入参就做了类型的限制，防止传入类型不匹配的参数。
还有一个好处是，使用密封类的话，when 表达式可以覆盖所有情况，不需要再添加 else 语句（表达式即有返回值的 when , 没有返回值的称为 when 语句）。
sealed class 究竟做了什么？
同样地，让我们来看看 sealed class 在 java 层面做了什么，实现了前面的效果。 上述密封类反编译得到的 java 代码如下：
public final class Exception extends Result {
private final int code;
@NotNull
private final String message;
public final int getCode() {
return this.code;
}
@NotNull
public final String getMessage() {
return this.message;
}
public Exception(int code, @NotNull String message) {
Intrinsics.checkParameterIsNotNull(message, "message");
super((DefaultConstructorMarker)null);
this.code = code;
this.message = message;
}
}
// Success.java
import kotlin.Metadata;
import kotlin.jvm.internal.DefaultConstructorMarker;
public final class Success extends Result {
private final int code;
public final int getCode() {
return this.code;
}
public Success(int code) {
super((DefaultConstructorMarker)null);
this.code = code;
}
}
// Result.java
import kotlin.Metadata;
import kotlin.jvm.internal.DefaultConstructorMarker;
// 最重要的地方
public abstract class Result {
private Result() {
}
// $FF: synthetic method
public Result(DefaultConstructorMarker $constructor_marker) {
this();
}
}
可以看到，Result 类其实是一个抽象类，Success 和 Exception 继承了这个抽象类。
Result 类的构造函数是私有的，不能在外部访问到
通过继承这个抽象类，达到限制类型的做法。
这其实和 java 中使用接口来限定参数类型的做法类似，很好理解
总结
枚举的局限性
- 限制枚举每个类型只允许有一个实例
- 限制所有枚举常量使用相同的类型的值
抽象类的局限性
对于一个抽象类我们可以用一些子类去继承它，但是子类不是固定的，它可以随意扩展，同时也失去枚举常量受限性。
枚举作为单例的优点
| 是否只有一个实例 | 是否反序列化 | 是否是线程安全 | 是否是懒加载 |
|---|---|---|---|
| 是 | 是 | 是 | 否 |
Sealed Classes 是什么？
Sealed 是一个 abstract 类，它本身是不能被实例化，只能用它的子类实例化对象。Sealed 的构造方法私有化，禁止在 Sealed 所定义的文件外使用。
- Sealed Classes 用于表示受限制的类层次结构
- 从某种意义上说，Sealed Classes 是枚举类的扩展
- 枚举的不同之处在于，每个枚举常量仅作为单个实例存在，而 Sealed Classes 的子类可以表示不同状态的实例。
在什么情况下使用枚举或者 Sealed？
如果涉及反序列化创建对象的时候，建议使用枚举，因为 Java 规定，枚举的序列化和反序列化是有特殊定制的，因此禁用编译器使用
writeObject、readObject、readObjectNoData、writeReplace、readResolve等方法。如果你不需要多次实例化，也不需要不提供特殊行为，或者也不需要添加额外的信息，仅作为单个实例存在，这个时候使用枚举更加合适。
其他情况下使用 Sealed Classes，在一定程度上可以使用 Sealed Classes 代替枚举
快捷键
自动补全 when 语句下的所有分支
Alt + Enter ---> Add remaining braches
原文
https://juejin.cn/post/6844904163835396103
https://juejin.cn/post/6859980718588575757
