Classi interne Ereditarietà in Kotlin

Question

Sto provando a creare una gerarchia di poche classi, ognuna delle quali sovrascrive alcuni comportamenti nelle classi interne del suo genitore (in particolare iteratori, ma non importa). In sostanza, sembra che questo:

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

compilatore si rifiuta di lavorare con questo codice, aspettandosi parametro type sulla classe interna quando ChildInnerClass eredita da essa. Tuttavia, dopo l'aggiunta dei parametri in questo modo:

protected inner class ChildInnerClass:InnerClass<T> 

compilatore non improvvisamente non aspettarsi alcun parametri di tipo!

Java equivalente di questa compila ed esegue come previsto, senza parametri di tipo:

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

Quindi, sono io che faccio qualcosa di sbagliato in Kotlin, o è semplicemente una restrizione lingua non ero a conoscenza circa?

Answer 1

Il compilatore non prevede un argomento di tipo su InnerClass ma su SuperClass in SuperClass.InnerClass. Questo è un problema noto: Capture generics in inner classes : KT-9208.

Per ora è possibile effettuare le seguenti operazioni:

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

Vedi anche Hadoop Context type parameters in Kotlin per un esempio simile e risposta.