构造函数中Kotlin函数的非终函数调用

Question

abstract class Base {
    var code = calculate()
    abstract fun calculate(): Int
}

class Derived(private val x: Int) : Base() {
    override fun calculate(): Int = x
}

fun main(args: Array<String>) {
    val i = Derived(42).code // Expected: 42, actual: 0
    println(i)
}

这是我在编写java时从未考虑过的，因为我使用这个模式时没有任何问题：

class Base {

    private int area;

    Base(Room room) {
        area = extractArea(room);
    }

    abstract int extractArea(Room room);
}

class Derived_A extends Base {

    Derived_A(Room room) {
        super(room);
    }

    @Override
    public int extractArea(Room room) {
        // Extract area A from room
    }
}

class Derived_B extends Base {

    Derived_B(Room room) {
        super(room);
    }

    @Override
    public int extractArea(Room room) {
        // Extract area B from room
    }
}

这样做效果很好，因为重写的extractarea函数不依赖于任何未初始化的数据，但是它们对于每个派生的类都是唯一的（因此需要抽象）。这在科特林也有效，但它仍然给出了警告。

那么在Java/Kotlin中这种做法是不是很糟糕呢？如果有，我该如何改进？是否可以在kotlin中实现而不被警告在构造函数中使用非final函数？

一个可能的解决方案是将are=extractArea()行移动到每个派生构造函数，但这似乎并不理想，因为它只是重复的代码，应该是超级类的一部分。

Answer 1

在语言参考：派生类初始化顺序中描述了派生类的初始化顺序，该节还解释了为什么在类的初始化逻辑中使用打开成员是一种不好的（而且可能是危险的）做法。

基本上，在执行超类构造函数（包括其属性初始化器和init块）时，派生类构造函数尚未运行。但是，即使从超类构造函数调用，被重写的成员仍保留其逻辑。这可能导致从超级构造函数调用依赖于特定于派生类的某些状态的重写成员，这可能导致bug或运行时失败。这也是在Kotlin中获得NullPointerException的情况之一。

考虑以下代码示例：

open class Base {
    open val size: Int = 0
    init { println("size = $size") }
}

class Derived : Base() {
    val items = mutableListOf(1, 2, 3)
    override val size: Int get() = items.size
}

正如@Bob Dagleish正确指出的，您可以对code属性使用惰性初始化：

val code by lazy { calculate() }

但是您需要小心，不要在基类构造逻辑中的任何其他地方使用code。

另一个选项是要求将code传递给基类构造函数：

abstract class Base(var code: Int) {
    abstract fun calculate(): Int
}

class Derived(private val x: Int) : Base(calculateFromX(x)) {
    override fun calculate(): Int = 
        calculateFromX(x)

    companion object {
        fun calculateFromX(x: Int) = x
    }
}