联合类型/扩展接口

Question

我有几个带有字段的data class，它们在表单中使用，如果任何字段已填写，则需要它们有一个方法返回true。

我不想为所有的类都重写这个，所以我现在这样做：

data class Order(var consumer: String, var pdfs: List<URI>): Form  {

    override val isEmpty(): Boolean
         get() = checkEmpty(consumer, pdfs)
}

data class SomethingElse(var str: String, var set: Set<String>): Form  {

    override val isEmpty(): Boolean
         get() = checkEmpty(str, set)
}


interface Form {
    val isEmpty: Boolean

    fun <T> checkEmpty(vararg fields: T): Boolean {
        for (f in fields) {
            when (f) {
                is Collection<*> -> if (!f.isEmpty()) return false
                is CharSequence -> if (!f.isBlank()) return false
            }
        }
        return true;
    }
}

这显然不是很漂亮也不是类型安全的。

在不将每个属性抽象为某种Field-type 的情况下，还有什么更惯用的方法？

澄清：我正在寻找的是一种详尽的when，例如通过提供所有允许的类型（String、Int、List、@ 987654329@) 和一个函数来判断它们是否为空。就像一个带有 isEmptyFormField 方法的“扩展接口”。

Answer 1

这有点老套，但应该可以。 每个data class 为每个构造函数参数创建一组方法。它们被称为componentN()（其中N 是从1 开始的数字，表示构造函数参数）。

您可以将这些方法放在您的界面中，并让data class 隐式实现它们。请参见下面的示例：

data class Order(var consumer: String, var pdfs: List) : Form

data class SomethingElse(var str: String, var set: Set) : Form

interface Form {
    val isEmpty: Boolean
        get() = checkEmpty(component1(), component2())

    fun  checkEmpty(vararg fields: T): Boolean {
        for (f in fields) {
            when (f) {
                is Collection -> if (!f.isEmpty()) return false
                is CharSequence -> if (!f.isBlank()) return false
            }
        }
        return true;
    }

    fun component1(): Any? = null
    fun component2(): Any? = null
}

您还可以添加fun component3(): Any? = null 等...以处理data class 中超过2 个字段的案例（例如NullObject 模式或直接在checkEmpty() 方法中处理nulls。

正如我所说，这有点老套，但也许对你有用。

Answer 2

如果您所做的只是检查isEmpty/isBlank/isZero/等。那么您可能不需要通用的checkEmpty 函数等：

data class Order(var consumer: String, var pdfs: List<URI>) : Form {
    override val isEmpty: Boolean
        get() = consumer.isEmpty() && pdfs.isEmpty()
}

data class SomethingElse(var str: String, var set: Set<String>) : Form {
    override val isEmpty: Boolean
        get() = str.isEmpty() && set.isEmpty()
}

interface Form {
    val isEmpty: Boolean
}

但是，如果您实际上要做一些更复杂的事情，那么根据您添加的说明，我相信“将每个属性抽象为某种 Field-type”正是您想要的，只是不要使 @ 987654327@ 实例是每个 data class 的一部分，而是在需要时创建它们的列表：

data class Order(var consumer: String, var pdfs: List<URI>) : Form {
    override val fields: List<Field<*>>
        get() = listOf(consumer.toField(), pdfs.toField())
}

data class SomethingElse(var str: String, var set: Set<String>) : Form {
    override val fields: List<Field<*>>
        get() = listOf(str.toField(), set.toField())
}

interface Form {
    val isEmpty: Boolean
        get() = fields.all(Field<*>::isEmpty)

    val fields: List<Field<*>>
}

fun String.toField(): Field<String> = StringField(this)
fun <C : Collection<*>> C.toField(): Field<C> = CollectionField(this)

interface Field<out T> {
    val value: T
    val isEmpty: Boolean
}

data class StringField(override val value: String) : Field<String> {
    override val isEmpty: Boolean
        get() = value.isEmpty()
}

data class CollectionField<out C : Collection<*>>(override val value: C) : Field<C> {
    override val isEmpty: Boolean
        get() = value.isEmpty()
}

这为您提供类型安全，而无需更改您的 data class 组件等，并允许您“获取详尽的 when”。

Answer 3

您可以使用null 表示“未指定”：

data class Order(var consumer: String?, var pdfs: List<URI>?) : Form {
    override val isEmpty: Boolean
        get() = checkEmpty(consumer, pdfs)
}

data class SomethingElse(var str: String?, var set: Set<String>?) : Form {
    override val isEmpty: Boolean
        get() = checkEmpty(str, set)
}

interface Form {
    val isEmpty: Boolean
    fun <T> checkEmpty(vararg fields: T): Boolean = fields.all { field -> field == null }
}

这里的想法与 Java 中的 Optional<T> 相同，但没有额外的对象等。

您现在必须担心null safety，但如果您的字段意味着有缺席/空的概念，那么这似乎是合适的 (UsingAndAvoidingNullExplained · google/guava Wiki)。