如何在Kotlin中继承可变列表？

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

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

class CompositeJob:MutableList{
有趣的工作{
为了（这项工作）{
作业。取消（）
}
}
}

但我得到了以下错误：

类“CompositeJob”不是抽象的，并且不实现抽象成员
公共抽象值大小：在kotlin.collections.MutableList中定义的Int

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

---

谢谢。

我已经测试过了，您需要将

合成作业

作为

摘要

作为错误提示。之后，您可以从

MutableList

因此，您的代码如下所示：

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

  }

override fun isEmpty(): Boolean 
     {

     }
}

抽象类CompositeJob:MutableList{
覆盖乐趣添加（元素：作业）：布尔值
{
}
override fun isEmpty（）：布尔值
{
}
}

是一个接口-它不实现任何方法，只声明它们。如果你想从头开始实现

MutableList

，你必须实现它的所有20个方法加上

size

属性，正如你的错误已经告诉你的那样

但是，您可以将此接口的实际实现子类化，例如：

class CompositeJob:ArrayList（）{
有趣的工作{
为了（这项工作）{
作业。取消（）
}
}
}

---

---

编辑：如果您只是想对协同程序

作业

实例进行分组，此时应使用父级、a和，而不是手动收集这样的作业。

实现所有成员并不是实现所需的唯一方法
更简单的方法是创建如下扩展函数：

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

fun MutableList.cancelAllJobs（）{
this.forEach{it.cancel（）}
} 

---

现在您可以为每个

MutableList

对象调用

myList.cancelAllJobs（）

其他答案没有提及的一个选项是：

class CompositeJob:MutableList by mutableListOf（）的MutableList{
有趣的工作{
为了（这项工作）{
作业。取消（）
}
}
}

基本相当于

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()
        }
    }
}

class CompositeJob:MutableList{
private val impl:MutableList=mutableListOf（）
重写fun size（）=impl.size（）
重写fun add（x:Job）{impl.add（x）}
//所有其他可变列表方法的etc
有趣的工作{
为了（这项工作）{
作业。取消（）
}
}
}

如果要避免继承，或者如果具体类方法标记为

final

，则可以使用组合并重定向所有未被重写的方法调用。以下是一个模板：

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)
}

类MyMutableList:MutableList{
private val list=mutableListOf（）
覆盖val size get（）=list.size
//可变列表
重写fun add（元素：T）：Boolean=list.add（元素）
覆盖乐趣添加（索引：Int，元素：T）=列表。添加（索引，元素）
覆盖有趣的addAll（元素：集合）：Boolean=list.addAll（元素）
重写fun addAll（索引：Int，元素：Collection）：Boolean=list.addAll（索引，元素）
override fun clear（）=list.clear（）
覆盖移除（元素：T）：布尔=列表。移除（元素）
override fun removeAll（元素：集合）：Boolean=list.removeAll（元素）
重写fun removeAt（索引：Int）：T=list.removeAt（索引）
override fun retainAll（元素：集合）：Boolean=list.retainAll（元素）
覆盖有趣的集合（索引：Int，元素：T）：T=list.set（索引，元素）
//名单
覆盖fun-contains（元素：T）：Boolean=list.contains（元素）
重写fun containsAll（元素：集合）：布尔=列表。containsAll（元素）
重写fun-get（索引：Int）：T=list.get（索引）
重写fun indexOf（元素：T）：Int=list.indexOf（元素）
override fun isEmpty（）：Boolean=list.isEmpty（）
重写有趣的迭代器（）：MutableIterator=list.iterator（）
覆盖lastIndexOf（元素：T）：Int=list.lastIndexOf（元素）
重写有趣的listIterator（）：MutableListIterator=list.listIterator（）
重写有趣的listIterator（索引：Int）：MutableListIterator=list.listIterator（索引）
覆盖乐趣子列表（从索引：Int，到索引：Int）：可变列表=
列表.子列表（从索引到索引）
}

---

…当然，这可能会增加一个额外的间接层，可能会影响列表性能，但会带来一些开销。

将鼠标指向

CompositeJob

类名，然后执行

Alt+Enter

，现在这些方法已部分为您实现。BTW实现<代码> MutableList <代码>是一个麻烦的IMO，你会考虑扩展到<代码> ARAYLIST < /COD>吗？我如何创建一个空的CypIDeJOB实例？你可以通过调用它的构造函数：<代码> ValCo＝CyryEffJOB（）/<代码>来创建一个实例，和EY一样简单。Cheesin KMM

ArrayList

此类型是最终类型，因此无法从中继承

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()
        }
    }
}

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)
}