虽然在层次结构中正确地实现equals()确实相当困难，但支持继承其他方法仍然很好，例如:toString()。

为了更具体一点，让我们假设我们有以下结构(显然，它不起作用，因为toString()不是继承的，但如果它不是很好吗?):

abstract class ResourceId(open val basePath: BasePath, open val id: Id) {

    // non of the subtypes inherit this... unfortunately...
    override fun toString(): String = "/${basePath.value}/${id.value}"
}

data class UserResourceId(override val id: UserId) : ResourceId(UserBasePath, id)

data class LocationResourceId(override val id: LocationId) : ResourceId(LocationBasePath, id)

Assuming our User and Location entities return their appropriate resource IDs (UserResourceId and LocationResourceId respectively), calling toString() on any ResourceId could result in quite a nice little representation that is generally valid for all subtypes: /users/4587, /locations/23, etc. Unfortunately, because non of the subtypes inherited to overridden toString() method from the abstract base ResourceId, calling toString() actually results in a less pretty representation: <UserResourceId(id=UserId(value=4587))>, <LocationResourceId(id=LocationId(value=23))>

还有其他方法可以对上述模型进行建模，但这些方法要么迫使我们使用非数据类(错过了数据类的许多好处)，要么我们最终在所有数据类中复制/重复toString()实现(没有继承)。

在构造函数外的超类中将属性声明为抽象，并在子类中重写它们。

abstract class Resource {
    abstract var id: Long
    abstract var location: String
}

data class Book (
    override var id: Long = 0,
    override var location: String = "",
    var isbn: String
) : Resource()

事实是:数据类不能很好地处理继承。我们正在考虑禁止或严格限制数据类的继承。例如，众所周知，在非抽象类的层次结构中无法正确地实现equals()。

因此，我所能提供的是:不要对数据类使用继承。

data class User(val id: Long, var name: String)

fun main() {
    val user1 = User(id:1, name:"Kart")
    val name = user1.name
    println(name)
    user1.name = "Michel"
    val user2 = User(id:1, name:"Michel")
    println(user1 == user2)
    println(user1)
    val updateUser = user1.copy(name = "DK DK")
    println(updateUser)
    println(updateUser.component1())
    println(updateUser.component2())
    val (id, name) = updateUser
    println("$id,$name")
}

//here is the output below

检查图像为什么它显示错误id:1(编译器说使用=而不是双点，我插入的值)

可以从非数据类继承数据类。

基类

open class BaseEntity (

@ColumnInfo(name = "name") var name: String? = null,
@ColumnInfo(name = "description") var description: String? = null,
// ...
)

子类

@Entity(tableName = "items", indices = [Index(value = ["item_id"])])
data class CustomEntity(

    @PrimaryKey
    @ColumnInfo(name = "id") var id: Long? = null,
    @ColumnInfo(name = "item_id") var itemId: Long = 0,
    @ColumnInfo(name = "item_color") var color: Int? = null

) : BaseEntity()

它工作。

上述方案使用抽象类实际生成相应的类，并让数据类从它扩展。

如果您不喜欢抽象类，那么使用接口如何?

Kotlin中的接口可以具有本文所示的属性。

interface History {
    val date: LocalDateTime
    val name: String
    val value: Int
}

data class FixedHistory(override val date: LocalDateTime,
                        override val name: String,
                        override val value: Int,
                        val fixedEvent: String) : History

我很好奇Kotlin是如何编译的。下面是等价的Java代码(使用Intellij [Kotlin字节码]特性生成):

public interface History {
   @NotNull
   LocalDateTime getDate();

   @NotNull
   String getName();

   int getValue();
}

public final class FixedHistory implements History {
   @NotNull
   private final LocalDateTime date;
   @NotNull
   private final String name;
   private int value;
   @NotNull
   private final String fixedEvent;

   // Boring getters/setters as usual..
   // copy(), toString(), equals(), hashCode(), ...
}

正如您所看到的，它的工作方式完全像一个普通的数据类!