Kotlin中的内部类继承

我试图创建一个由几个类组成的层次结构，每个类都覆盖其父类的内部类中的一些行为（特别是迭代器，但这并不重要）。基本上，它看起来是这样的：

open class SuperClass<T>{
    protected open inner class InnerClass{
        fun someLogic(){
            println("some logic happened")
        }

        open fun someOverridableLogic(){
            println("some logic happened")
        }
    }
}

class ChildClass<T> : SuperClass<T>(){
    protected inner class ChildInnerClass:InnerClass{
        override fun someOverridableLogic(){
            super.someOverridableLogic()
            println("some OTHER logic happened")
        }
    }
}

protected inner class ChildInnerClass:InnerClass<T>

开放类超类{
受保护的开放内部类InnerClass{
有趣的逻辑{
println（“发生了一些逻辑”）
}
打开可重写逻辑（）{
println（“发生了一些逻辑”）
}
}
}
类ChildClass:SuperClass（）{
受保护的内部类ChildInnerClass:InnerClass{
重写可重写逻辑（）{
super.someOverridableLogic（）
println（“发生了其他逻辑”）
}
}
}

编译器拒绝使用此代码，当ChildInnerClass从其继承时，InnerClass上需要类型参数。但是，在添加如下参数后：

open class SuperClass<T>{
    protected open inner class InnerClass{
        fun someLogic(){
            println("some logic happened")
        }

        open fun someOverridableLogic(){
            println("some logic happened")
        }
    }
}

class ChildClass<T> : SuperClass<T>(){
    protected inner class ChildInnerClass:InnerClass{
        override fun someOverridableLogic(){
            super.someOverridableLogic()
            println("some OTHER logic happened")
        }
    }
}

protected inner class ChildInnerClass:InnerClass<T>

受保护的内部类ChildInnerClass:InnerClass

编译器突然不需要任何类型参数

与此类似的Java按照预期编译和执行，不带类型参数：

public class SuperClass<T> {
    protected class InnerClass{
        public void someLogic(){
            System.out.println("some logic happened");
        }

        public void someOverridableLogic(){
            System.out.println("some logic happened");
        }
    }
}


public class ChildClass<T> extends SuperClass<T>{
    protected class ChildInnerClass extends InnerClass{
        @Override
        public void someOverridableLogic() {
            super.someOverridableLogic();
            System.out.println("some OTHER logic happened");
        }
    }
}

公共类超类{
受保护类内部类{
公共逻辑{
System.out.println（“发生了一些逻辑”）；
}
public void someOverridableLogic（）{
System.out.println（“发生了一些逻辑”）；
}
}
}
公共类ChildClass扩展了超类{
受保护类ChildInnerClass扩展InnerClass{
@凌驾
public void someOverridableLogic（）{
super.someOverridableLogic（）；
System.out.println（“发生了其他一些逻辑”）；
}
}
}

---

那么，我是否在Kotlin中做了一些错误的事情，或者这仅仅是一个我不知道的语言限制？

编译器不希望在

InnerClass

上使用类型参数，而是在

SuperClass.InnerClass

中的

SuperClass

上使用类型参数。这是一个已知问题：

目前，您可以执行以下操作：

open class SuperClass<T> {
    protected open inner class InnerClass {
        fun someLogic() {
            println("some logic happened")
        }

        open fun someOverridableLogic() {
            println("some logic happened")
        }
    }
}

class ChildClass<T> : SuperClass<T>() {
    protected inner class ChildInnerClass : SuperClass<T>.InnerClass() {
        override fun someOverridableLogic() {
            super.someOverridableLogic()
            println("some OTHER logic happened")
        }
    }
}

开放类超类{
受保护的开放内部类InnerClass{
有趣的逻辑{
println（“发生了一些逻辑”）
}
打开可重写逻辑（）{
println（“发生了一些逻辑”）
}
}
}
类ChildClass:SuperClass（）{
受保护的内部类ChildInnerClass:超类。InnerClass（）{
重写可重写逻辑（）{
super.someOverridableLogic（）
println（“发生了其他逻辑”）
}
}
}

---

另请参见类似的示例和答案。

我刚接触Kotlin，因此背上一个问题：我正试图了解这一点，但答案上的代码并不适合我。我还必须在

InnerClass

上添加类型参数，因此它最终成为

InnerClass ChildInnerClass:SuperClass.InnerClass（）

，我认为链接的答案建议这样做。。。我缺少什么吗？只有在使用类型参数（

protected open internal class InnerClass

）定义类型参数时，才需要在

InnerClass

上指定类型参数。在该代码中，

InnerClass

不需要类型参数，而是使用其父级的T，

超类

@Augusto如果答案中的代码没有为您编译，那么我猜您对

内部类

等进行了一些更改。因此，为了清楚起见，我更新了答案中的代码，以包含

超类

声明。您应该能够将示例复制并粘贴到一个新的Kotlin文件中，并且它应该能够顺利编译。如果不适合你，请告诉我们。我真傻！在玩代码时，我在某个点上将

添加到了

超类.InnerClass

。谢谢你澄清这一点！！！