Kotlin to Java interoperability in hierarchial interfaces

Question

I have two modules defines like this:

interface Module {
    val parameter: JSONObject
}

abstract class FirstModule: Module {
    abstract val message: Message
}
....
// many more Modules

I created a base listener interface for Module and another for FirstModule:

fun interface ModuleListener {
    fun ready(module: Module)
}

fun interface FirstModuleListener: ModuleListener {
    fun ready(module : FirstModule)

    override fun ready(module: Module) {
        ready(module as FirstModule)
    }
}

assuming there is a function named firstModule() like this:

fun firstModule(listener: FirstModuleListener)

In KOTLIN when I call firstModule() things work as expected (to let user only override ready() with FirstModule as parameter:

firstModule ( object: FirstModuleListener {
       override fun ready(module: FirstModule) {
           Log.v(TAG, "module: $module)
       }
    }
}

but the same is behaving differently in JAVA. It is expecting user to override both the interface methods even when one of them is already overridden and has some content in child interface.

firstModule(new FirstModuleListener() {
   @Override public void ready(Module module) { }

   @Override public void ready(FirstModule module) {}
}

How can I skip the first overridden method call in Java. Is it causing due to the method definition support in Kotlin and not in Java?

Not an answer but worth noting that this unsafe cast `ready(module as FirstModule)` in a public method seems like a disaster waiting to happen, if the user knows it's a FirstModule they can already use the other method, so this method serves no purpose other than guaranteed crashing. Of course this might just look weird because of a lack of context or because this is just an example to illustrate the question. — somethingsomething, Nov 19 '21 at 10:02
the method `firstModule` accepts FirstModuleListener only which eventually asks user (in kotlin) to override the `ready(module: FirstModule)` only. So I think its ok for this. But thanks for pointing out. — Sandeep Gupta, Nov 22 '21 at 14:00

Future Deep Gone · Answer 1 · 2021-11-23T01:49:33.150

Essentially: When kotlin implements FirstModuleListener interface, it still implements two ready().

In FirstModuleListener, fun ready(module: FirstModule) is an abstract method, and

override fun ready(module: Module) {
        ready(module as FirstModule)
    }

It is a concrete realization method.

The interface in kotlin can define specific methods, and the kotlin compiler behind it is converted into the corresponding static method in Java. Your FirstModuleListener defines both abstract and non-abstract methods.

Kotlin will generate a DefaultImpls static inner class to implement the ready(module: Module) method of FirstModuleListener at compile time.

public interface FirstModuleListener extends ModuleListener {
   void ready(@NotNull FirstModule var1);

   void ready(@NotNull Module var1);

   @Metadata(
      mv = {1, 5, 1},
      k = 3
   )
   public static final class DefaultImpls {
      public static void ready(@NotNull FirstModuleListener $this, @NotNull Module module) {
         Intrinsics.checkNotNullParameter(module, "module");
         $this.ready((FirstModule)module);
      }
   }
}

When implementing FirstModuleListener, a ready() essentially calls ready() of DefaultImpls.

 firstModule((FirstModuleListener)(new FirstModuleListener() {
         public void ready(@NotNull FirstModule module) {
            Intrinsics.checkNotNullParameter(module, "module");
         }

         public void ready(@NotNull Module module) {
            Intrinsics.checkNotNullParameter(module, "module");
            FirstModuleListener.DefaultImpls.ready(this, module);
         }
      }));

This is no different from Java.

#################################################

interface Module {
    val parameter: JSONObject
}

abstract class FirstModule : Module {
    abstract val message: String
}

abstract class SecondModule : Module {
    abstract val message: String
}

interface ModuleListener {
    fun ready(module: Module)
}

fun firstModule(listener: ModuleListener)

fun main() {
    firstModule(object : ModuleListener {
        override fun ready(module: Module) {
            when (module) {
                is FirstModule -> {
                    Log.v(TAG, "module: $module)
                }
                is SecondModule -> {
                    //...
                }
            }
        }
    })
}

True that it is not different from Java. But then again, is there any way to get rid of this? My requirement is to allow user only have the specific module related `ready` method accessible. If I use abstract classes instead of interfaces then lambdas can't be used. — Sandeep Gupta, Nov 22 '21 at 13:51
In my opinion, you should judge the type from the passed parameter, so that only one ready() is needed. — Future Deep Gone, Nov 23 '21 at 01:46

Kotlin to Java interoperability in hierarchial interfaces

1 Answers1