覆盖 Kotlin 数据类的 getter

Question

给定以下 Kotlin 类：

data class Test(val value: Int)

如何覆盖 Int getter 以便在值为负时返回 0？

如果这不可能，有哪些技术可以达到合适的结果？

Answer 1

在每天花费将近一整年的时间编写 Kotlin 之后，我发现尝试像这样覆盖数据类是一种不好的做法。有 3 种有效的方法，在我介绍它们之后，我将解释为什么其他答案建议的方法不好。

1. 让创建 data class 的业务逻辑将值更改为 0 或更大，然后再调用具有错误值的构造函数。 这可能是大多数情况下的最佳方法。

2. 不要使用data class。使用常规的 class 并让您的 IDE 为您生成 equals 和 hashCode 方法（或者不要，如果您不需要它们）。是的，如果对象的任何属性发生更改，您必须重新生成它，但您可以完全控制对象。

   class Test(value: Int) {
     val value: Int = value
       get() = if (field < 0) 0 else field
   
     override fun equals(other: Any?): Boolean {
       if (this === other) return true
       if (other !is Test) return false
       return true
     }
   
     override fun hashCode(): Int {
       return javaClass.hashCode()
     }
   }
   

3. 在对象上创建一个额外的安全属性来执行您想要的操作，而不是拥有一个被有效覆盖的私有值。

   data class Test(val value: Int) {
     val safeValue: Int
       get() = if (value < 0) 0 else value
   }
   

其他答案建议的不好的方法：

data class Test(private val _value: Int) {
  val value: Int
    get() = if (_value < 0) 0 else _value
}

这种方法的问题在于data classes 并不是真正用于更改这样的数据。它们实际上只是用于保存数据。像这样覆盖数据类的 getter 意味着 Test(0) 和 Test(-1) 不会彼此 equal 并且会有不同的 hashCodes，但是当你调用 .value 时，它们会得到相同的结果.这是不一致的，虽然它可能对您有用，但您团队中的其他人看到这是一个数据类，可能会在没有意识到您如何更改它/使其无法按预期工作的情况下意外滥用它（即这种方法不会在Map 或Set 中无法正常工作。

Answer 2

你可以试试这样的：

data class Test(private val _value: Int) {
  val value = _value
    get(): Int {
      return if (field < 0) 0 else field
    }
}

assert(1 == Test(1).value)
assert(0 == Test(0).value)
assert(0 == Test(-1).value)

assert(1 == Test(1)._value) // Fail because _value is private
assert(0 == Test(0)._value) // Fail because _value is private
assert(0 == Test(-1)._value) // Fail because _value is private

• 在数据类中，您必须使用val 或var 标记主构造函数的参数。

• 我将_value 的值分配给value，以便使用所需的属性名称。

• 我使用您描述的逻辑为属性定义了一个自定义访问器。

Answer 3

答案取决于data 提供的您实际使用的功能。 @EPadron 提到了一个绝妙的技巧（改进版）：

data class Test(private val _value: Int) {
    val value: Int
        get() = if (_value < 0) 0 else _value
}

这将按预期工作，即它有 一个 字段，一个吸气剂，正确的 equals、hashcode 和 component1。问题是 toString 和 copy 很奇怪：

println(Test(1))          // prints: Test(_value=1)
Test(1).copy(_value = 5)  // <- weird naming

要解决toString 的问题，您可以手动重新定义它。我知道没有办法修复参数命名，但根本不使用data。

Answer 4

我已经看到你的回答，我同意数据类仅用于保存数据，但有时我们需要从中做出一些东西。

这是我对数据类所做的事情，我将一些属性从 val 更改为 var，并在构造函数中覆盖它们。

像这样：

data class Recording(
    val id: Int = 0,
    val createdAt: Date = Date(),
    val path: String,
    val deleted: Boolean = false,
    var fileName: String = "",
    val duration: Int = 0,
    var format: String = " "
) {
    init {
        if (fileName.isEmpty())
            fileName = path.substring(path.lastIndexOf('\\'))

        if (format.isEmpty())
            format = path.substring(path.lastIndexOf('.'))

    }


    fun asEntity(): rc {
        return rc(id, createdAt, path, deleted, fileName, duration, format)
    }
}

Answer 5

我知道这是一个老问题，但似乎没有人提到将 value 设为私有并像这样编写自定义 getter 的可能性：

data class Test(private val value: Int) {
    fun getValue(): Int = if (value < 0) 0 else value
}

这应该是完全有效的，因为 Kotlin 不会为私有字段生成默认 getter。

但除此之外，我绝对同意 spierce7 的观点，即数据类用于保存数据，您应该避免在其中硬编码“业务”逻辑。

Answer 6

似乎是一个古老但有趣的问题。 只想贡献一个选项：

data class Test(@JvmField val value: Int){
    fun getValue() = if(value<0) 0 else value
}

现在您可以覆盖 getValue，并且仍然可以让 component1() 正常工作。

Answer 7

我发现以下方法是在不破坏 equals 和 hashCode 的情况下实现您需要的最佳方法：

data class TestData(private var _value: Int) {
    init {
        _value = if (_value < 0) 0 else _value
    }

    val value: Int
        get() = _value
}

// Test value
assert(1 == TestData(1).value)
assert(0 == TestData(-1).value)
assert(0 == TestData(0).value)

// Test copy()
assert(0 == TestData(-1).copy().value)
assert(0 == TestData(1).copy(-1).value)
assert(1 == TestData(-1).copy(1).value)

// Test toString()
assert("TestData(_value=1)" == TestData(1).toString())
assert("TestData(_value=0)" == TestData(-1).toString())
assert("TestData(_value=0)" == TestData(0).toString())
assert(TestData(0).toString() == TestData(-1).toString())

// Test equals
assert(TestData(0) == TestData(-1))
assert(TestData(0) == TestData(-1).copy())
assert(TestData(0) == TestData(1).copy(-1))
assert(TestData(1) == TestData(-1).copy(1))

// Test hashCode()
assert(TestData(0).hashCode() == TestData(-1).hashCode())
assert(TestData(1).hashCode() != TestData(-1).hashCode())

然而，

首先，请注意_value 是var，而不是val，但另一方面，由于它是私有的并且无法继承数据类，因此很容易确保它没有在类。

其次，toString() 产生的结果与将_value 命名为value 时的结果略有不同，但它与TestData(0).toString() == TestData(-1).toString() 是一致的。

Answer 8

这似乎是 Kotlin 的一个（以及其他）令人讨厌的缺点。

似乎唯一合理的解决方案，完全保持类的向后兼容性是将其转换为常规类（不是“数据”类），并手动（在IDE的帮助下）实现方法: hashCode(), equals(), toString(), copy() 和 componentN()

class Data3(i: Int)
{
    var i: Int = i

    override fun equals(other: Any?): Boolean
    {
        if (this === other) return true
        if (other?.javaClass != javaClass) return false

        other as Data3

        if (i != other.i) return false

        return true
    }

    override fun hashCode(): Int
    {
        return i
    }

    override fun toString(): String
    {
        return "Data3(i=$i)"
    }

    fun component1():Int = i

    fun copy(i: Int = this.i): Data3
    {
        return Data3(i)
    }

}