Question

我正在尝试继承MutableList，并向其中添加我自己的函数。例如：

class CompositeJob : MutableList<Job> {
    fun cancelAllJobs() {
        for (job in this) {
            job.cancel()
        }
    }
}

但是我遇到了以下错误：

“ CompositeJob”类不是抽象的，并且没有实现抽象成员
公共抽象值大小：int in kotlin.collections.MutableList

如何继承MutableList，以便可以使用其原始方法（如add（）和isEmpty（））并添加自己的方法？

谢谢。

Answer 1

MutableList是一个接口-它不实现其任何方法，仅声明它们。如果您想从头开始实现MutableList，则必须实现其所有20种方法以及size属性，就像您的错误已经告诉您的那样。

但是，您可以继承该接口的实际实现，例如ArrayList或LinkedList：

class CompositeJob : ArrayList<Job>() {
    fun cancelAllJobs() {
        for (job in this) {
            job.cancel()
        }
    }
}

Answer 2

实现所有成员并不是实现您所需要的唯一方法。
一种更简单的方法是创建一个扩展函数，如下所示：

fun MutableList<Job>.cancelAllJobs() {
    this.forEach { it.cancel() }
}

现在，您可以为每个myList.cancelAllJobs()对象调用MutableList<Job>。

Answer 3

delegation其他未提及的选项：

class CompositeJob : MutableList<Job> by mutableListOf() {
    fun cancelAllJobs() {
        for (job in this) {
            job.cancel()
        }
    }
}

基本上等同于

class CompositeJob : MutableList<Job> {
    private val impl: MutableList<Job> = mutableListOf()
    override fun size() = impl.size()
    override fun add(x: Job) { impl.add(x) }
    // etc for all other MutableList methods

    fun cancelAllJobs() {
        for (job in this) {
            job.cancel()
        }
    }
}

Answer 4

正如我测试过的那样，您需要将CompositeJob设为abstract，这同样提示错误。之后，您可以覆盖add()

中的isEmpty()和MutableList

所以您的代码如下所示：

abstract class CompositeJob : MutableList<Job> {
override fun add(element:Job): Boolean
  {

  }

override fun isEmpty(): Boolean 
     {

     }
}

Answer 5

如果要避免继承，或者将具体的类方法标记为final，则可以使用composition并重定向所有未被覆盖的方法调用。这是一个模板：

class MyMutableList<T> : MutableList<T> {
    private val list = mutableListOf<T>()
    override val size get() = list.size

    // MutableList<T>
    override fun add(element: T): Boolean = list.add(element)
    override fun add(index: Int, element: T) = list.add(index, element)
    override fun addAll(elements: Collection<T>): Boolean = list.addAll(elements)
    override fun addAll(index: Int, elements: Collection<T>): Boolean = list.addAll(index, elements)
    override fun clear() = list.clear()
    override fun remove(element: T): Boolean = list.remove(element)
    override fun removeAll(elements: Collection<T>): Boolean = list.removeAll(elements)
    override fun removeAt(index: Int): T = list.removeAt(index)
    override fun retainAll(elements: Collection<T>): Boolean = list.retainAll(elements)
    override fun set(index: Int, element: T): T = list.set(index, element)

    // List<T>
    override fun contains(element: T): Boolean = list.contains(element)
    override fun containsAll(elements: Collection<T>): Boolean = list.containsAll(elements)
    override fun get(index: Int): T = list.get(index)
    override fun indexOf(element: T): Int = list.indexOf(element)
    override fun isEmpty(): Boolean = list.isEmpty()
    override fun iterator(): MutableIterator<T> = list.iterator()
    override fun lastIndexOf(element: T): Int = list.lastIndexOf(element)
    override fun listIterator(): MutableListIterator<T> = list.listIterator()
    override fun listIterator(index: Int): MutableListIterator<T> = list.listIterator(index)
    override fun subList(fromIndex: Int, toIndex: Int): MutableList<T> =
        list.subList(fromIndex, toIndex)
}

...当然，这可能会增加一个间接层，可能会以很小的开销影响列表性能。

如何在Kotlin中继承MutableList？

5 个答案: