3

我们有一个抽象的 Java 类（我们无法修改）AbstractClass，我们想在 Kotlin 中实现它。一个要求是 Kotlin 实现可以使用 vanilla Jackson Databind序列化/反序列化为 JSON 。这导致我们进行了以下实现：

class MyClass(private val data: MyClassData? = null) : AbstractClass<MyClassData>(MyClass::class.java, "1") {

    data class MyClassData(var name: String = "", var age: Int = 0) : AbstractData

    override fun getData(): MyClassData? {
        return data
    }
}

此类将始终从 Java 中使用，目前您可以像这样 (Java) 实例化它：

MyClass myClass = new MyClass(new MyClassData("John Doe", 25));

但我们更愿意像这样实例化它：

MyClass myClass = new MyClass("John Doe", 25);

我当然可以将 Kotlin 代码更改为如下所示：

class MyClass(@JsonIgnore private var name: String = "", @JsonIgnore private var age: Int = 0) : AbstractClass<MyClassData>(MyClass::class.java, "1") {

    data class MyClassData(var name: String = "", var age: Int = 0) : AbstractData

    private var data : MyClassData? = null

    init {
        data = MyClassData(name, age)
    }

    override fun getData(): MyClassData? {
        return data
    }
}

但这非常冗长，有点违背了使用 Kotlin 的目的。

我想我想做的是这样的（伪代码）：

class MyClass(private val data: MyClassData? = null by MyClassData) : AbstractClass<MyClassData>(MyClass::class.java, "1") {

    data class MyClassData(var name: String = "", var age: Int = 0) : AbstractData

    override fun getData(): MyClassData? {
        return data
    }
}

（注意构造函数by MyClassData中的MyClass显然不起作用）

即我想以某种方式破坏或委托 MyClass 的构造函数以采用与 MyClassData 相同的参数而不复制它们。这是您可以在 Kotlin 中做的事情，还是有另一种方法可以在不添加太多代码的情况下解决它？

4

1 回答 1

3

我认为您主要关心的是：（a）简洁的外部 API，（b）干净的内部状态（对于杰克逊）

二级构造函数

这很精简：

class MyClass internal constructor(private val data: MyClassData)
    : AbstractClass<MyClass>(MyClass::class.java, "1") {

    data class MyClassData(var name: String, var age: Int) : AbstractData

    constructor(name: String, age: Int) : this(MyClassData(name, age))

    override fun getData(): MyClassData? = data

}

无需创建额外字段的简单 API（尽管我认为这种语法具有误导性）：

val myClass = MyClass("John Doe", 25)

传递参数和初始化程序：

这是我的第一个想法：直接拉出外部类的参数（尽管我现在认为辅助构造函数更好，因为它不会污染外部类）：

class MyClass(@JsonIgnore private val name: String, @JsonIgnore private val age: Int)
    : AbstractClass<MyClass>(MyClass::class.java, "1") {

    data class MyClassData(var name: String, var age: Int) : AbstractData

    private val data = MyClassData(this@MyClass.name, this@MyClass.age)

    override fun getData(): MyClassData? = data

}

...再次，相同的 API：

val myClass = MyClass("John Doe", 25)

自工厂

这种方法可能具有更具描述性的语法：

class MyClass(private val data : MyClassData)
    : AbstractClass<MyClass>(MyClass::class.java, "1") {

    data class MyClassData(var name: String, var age: Int) : AbstractData

    companion object Factory {
        fun create(name: String, age: Int) = MyClass(MyClassData(name, age))
    }

    override fun getData(): MyClassData? = data

}

这可以这样调用：

val myClass = MyClass.Factory.create("John Doe", 25)

概念语法：结构化（不存在）

我有点喜欢方法参数的“结构化”语法的想法，它将输入分组到一个对象中（与解构相反）；有点像可变参数（即语法糖）：

class MyClass(
    private val data: (name: String, age: Int) : MyClassData(name, age)
) { ... }

这可以通过以下两种方式之一调用：

val myClass1 = MyClass(MyClassData("John Doe", 25))
val myClass2 = MyClass("John Doe", 25)

在实践中，这是一个罕见的要求，并且只需几个额外的字符即可通过显式重载轻松管理，所以我认为它永远不会发生。

于 2017-08-18T10:24:07.933 回答