是否可以将列表的类型限制为Kotlin中接口的实现？

我有一个类

潜行

实现接口

技能

和一个类

无声移动

实现接口

精通

。现在我想在

技能

隐身中添加精通

无声动作

，同时确保

技能

支持

精通

我想这样做（伪科特林）：

界面技巧{
val精通：列表//与类型技能相关的精通
}

及

界面掌握{//每一项掌握必须只与一项技能兼容
val masteryName:String
}

对于实现：

class Stealth : Skill {
    override val masteries: ArrayList<Mastery<Stealth>() // Any Mastery bound to Stealth
}

职业秘密：技能{
override val masteries:ArrayList我不知道我是否真正理解您，但我认为这段代码解决了您的问题：

interface Mastery<Skill> {
    val masteryName: String
}

interface Skill<Self : Skill<Self>> {                              // forces every Skill to bound to itself
    val masteries: List<Mastery<Self>>
}

abstract class Stealth : Skill<Stealth> {
    override val masteries = ArrayList<Mastery<Stealth>>()
}

class SoundlessMovement : Mastery<Stealth> {         // a Stealth mastery
    override val masteryName = "Soundless Movement"
}

class SoundlessMovement2 : Mastery<Stealth> {        // another Stealth mastery
    override val masteryName = "Soundless Movement 2"
}

abstract class Archery : Skill<Archery> {         
    override val masteries = ArrayList<Mastery<Archery>>()
}

class SureShot : Mastery<Archery> {                  // some other mastery
    override val masteryName = "Sure shot 2"
}

fun main(args: Array<String>) {

    var list = ArrayList<Mastery<Stealth>>()

    list.add(SoundlessMovement())            // compiles
    list.add(SoundlessMovement2())           // compiles
    list.add(SureShot())                     // Doesn't compile
}

界面掌握{
val masteryName:String
}
界面技能{//强制每个技能绑定到自身
val掌握：列表
}
抽象类：隐形技能{
覆盖val masteries=ArrayList（）
}
职业无声移动：精通{///潜行精通
覆盖val masteryName=“无声移动”
}
职业无声动作2：精通{//另一种隐形精通
覆盖val masteryName=“无声移动2”
}
抽象类射箭：技巧

请注意，
Self
不是一个保留字，也不是任何类似的词。如果您只需将其更改为just
T
，该代码也可以工作。我选择使用
Self
，只是为了让您知道应该放在那里的类型
我不知道是否真正理解您，但我认为这段代码解决了您的问题：

interface Mastery<Skill> {
    val masteryName: String
}

interface Skill<Self : Skill<Self>> {                              // forces every Skill to bound to itself
    val masteries: List<Mastery<Self>>
}

abstract class Stealth : Skill<Stealth> {
    override val masteries = ArrayList<Mastery<Stealth>>()
}

class SoundlessMovement : Mastery<Stealth> {         // a Stealth mastery
    override val masteryName = "Soundless Movement"
}

class SoundlessMovement2 : Mastery<Stealth> {        // another Stealth mastery
    override val masteryName = "Soundless Movement 2"
}

abstract class Archery : Skill<Archery> {         
    override val masteries = ArrayList<Mastery<Archery>>()
}

class SureShot : Mastery<Archery> {                  // some other mastery
    override val masteryName = "Sure shot 2"
}

fun main(args: Array<String>) {

    var list = ArrayList<Mastery<Stealth>>()

    list.add(SoundlessMovement())            // compiles
    list.add(SoundlessMovement2())           // compiles
    list.add(SureShot())                     // Doesn't compile
}

界面掌握{
val masteryName:String
}
界面技能{//强制每个技能绑定到自身
val掌握：列表
}
抽象类：隐形技能{
覆盖val masteries=ArrayList（）
}
职业无声移动：精通{///潜行精通
覆盖val masteryName=“无声移动”
}
职业无声动作2：精通{//另一种隐形精通
覆盖val masteryName=“无声移动2”
}
抽象类射箭：技巧

请注意，
Self
不是一个保留字，也不是任何类似的词。如果您只需将其更改为just
T
，代码也会起作用。我选择使用
Self
，只是为了让您知道应该放在那里的类型
我知道问题的标题不好。我只是不知道如何更好地使用des抄袭问题。你的类设计是不可理解的。为什么
Mastery
需要一个泛型参数，但不使用它？为什么Skill持有对其类的列表引用？你能解释一下你想要实现什么以及你的类关系吗。@Joshua该结构被简化为只显示代码中有问题的部分。简单地说，它我希望有一个类实现一个接口，该接口包含一个列表，该列表的类型与另一个类实现另一个接口并绑定到第一个类的类型相同。目标是通过将每项技能绑定到一项特定技能来防止技能和掌握的混合。因此Pelocho的答案正是我想要做的。我知道这个问题很糟糕。我只是不知道如何更好地描述这个问题。你的类设计是不可理解的。为什么
Mastery
需要一个泛型参数，但不使用它？为什么Skill持有对其类的列表引用？你能解释一下你想要实现什么以及你的类关系吗。@Joshua结构简化为o只显示代码中有问题的部分。简单地说，我尝试让一个类实现一个接口，该接口包含一个列表，该列表的类型与另一个类实现另一个接口并绑定到第一个类的类型相同。目标是通过将每项技能绑定到一项特定技能来防止技能和掌握的混合。因此Pelocho的答案是事实上，这正是我想要做的。啊！这很有道理。这也解释了为什么我从来没有听说过它。虽然它比
Foo
可读性更好。现在我知道
Self
不是一个关键词，我也明白了，代码的作用。它甚至比我想象的更简单。啊！这很有道理。这也解释了为什么我从来没有听说过它。这是打赌虽然比
Foo
可读性更好。现在我知道
Self
不是一个关键词，我也理解了代码的作用。它比我想象的还要简单。
class SoundlessMovement : Mastery<Stealth> { // Is a Mastery compatible with Stealth
    override val masteryName = "Soundless Movement"
}

interface Mastery<Skill> {
    val masteryName: String
}

interface Skill<Self : Skill<Self>> {                              // forces every Skill to bound to itself
    val masteries: List<Mastery<Self>>
}

abstract class Stealth : Skill<Stealth> {
    override val masteries = ArrayList<Mastery<Stealth>>()
}

class SoundlessMovement : Mastery<Stealth> {         // a Stealth mastery
    override val masteryName = "Soundless Movement"
}

class SoundlessMovement2 : Mastery<Stealth> {        // another Stealth mastery
    override val masteryName = "Soundless Movement 2"
}

abstract class Archery : Skill<Archery> {         
    override val masteries = ArrayList<Mastery<Archery>>()
}

class SureShot : Mastery<Archery> {                  // some other mastery
    override val masteryName = "Sure shot 2"
}

fun main(args: Array<String>) {

    var list = ArrayList<Mastery<Stealth>>()

    list.add(SoundlessMovement())            // compiles
    list.add(SoundlessMovement2())           // compiles
    list.add(SureShot())                     // Doesn't compile
}