是否可以像Java一样从子类引用嵌套类？

Question

There is a Java library I'm interacting with that has the following:

class Superclass {
    static class Nested {}
}

class Subclass extends Superclass {}

This is code is illegal in Kotlin:

class Test() {
    val thing1 = Superclass.Nested()
    val thing2 = Subclass.Nested()
}

The compiler says that Subclass.Nested is an unresolved reference. However, the equivalent Java code is not illegal:

class Test {
    Superclass.Nested thing1 = new Superclass.Nested();
    Subclass.Nested thing2 = new Subclass.Nested();
}

Is there some other way in Kotlin to reference a nested class by qualifying it with a subclass instead of the superclass?

(Why? Because there is an unusual deprecation pattern in play here: Superclass is deprecated and is being replaced by Subclass . The Nested class is going to be moved into Subclass later. That is the external constraint I am working under.)

Answer 1

I am not sure if this solves your problem, buy you can access the Nested class from the Subclass, so you could do something like this:

open class Superclass {
    class Nested
}

class Subclass : Superclass() {

    companion object Nested {
        operator fun invoke(): Superclass.Nested = Nested()
    }

}

class Test() {
    val thing1 = Superclass.Nested()
    val thing2 = Subclass.Nested()
}

Also, to avoid any confunsion you could just make a function that creates the Nested class

class Subclass : Superclass() {

    companion object {
        fun createNested() = Nested()
    }

}

Answer 2

As you can't access the source code or have to wait for the PR to be approved, I probably would try it with typealias instead, eg:

typealias MyNested = Superclass.Nested

and use it like:

MyNested()

As soon as Superclass is obsolete you only need to replace the type-alias, eg:

typealias MyNested = Subclass.Nested

That way you only have 1 place where you need to adapt your code when Superclass is removed.

It's now really a pity that both classes aren't under your control and that this feature of Java doesn't work in Kotlin. On the other hand I am really glad that it isn't. Something like Subclass.Nested when there actually isn't any such nested class there, isn't really convenient in my opinion. However, that's also what is possible with extension functions... so now I am in conflict ;-)

As also said in the comment: there might be a chance that this could also just be a bug. I didn't find any sources yet whether this was a deliberate design decision or not. It sounds good to me, but that doesn't mean it was intentional. You may want to ask the same question in the Kotlin forums or open an issue and link it here.