分层接口中 Kotlin 到 Java 的互操作性

Question

我有两个这样定义的模块：

interface Module {
    val parameter: JSONObject
}

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

我为Module 创建了一个基本侦听器接口，为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)
    }
}

假设有一个名为 firstModule() 的函数，如下所示：

fun firstModule(listener: FirstModuleListener)

在KOTLIN 中，当我调用firstModule() 时，事情按预期工作（让用户只用FirstModule 作为参数覆盖ready()：

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

但在JAVA 中表现不同。即使其中一个已经被覆盖并且在子界面中有一些内容，它也期望用户覆盖这两个接口方法。

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

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

如何跳过 Java 中的第一个被覆盖的方法调用。是不是因为 Kotlin 中的方法定义支持而不是 Java 中的？

Answer 1

本质上：当kotlin实现FirstModuleListener interface时，它仍然实现了两个ready()。

在FirstModuleListener中，fun ready(module: FirstModule)是一个抽象方法，并且

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

这是一个具体的实现方法。

kotlin中的接口可以定义具体的方法，其背后的kotlin编译器转换成Java中对应的静态方法。您的 FirstModuleListener 定义了抽象方法和非抽象方法。

Kotlin 会在编译时生成一个DefaultImpls 静态内部类来实现FirstModuleListener 的ready(module: Module) 方法。

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

在实现FirstModuleListener 时，ready() 本质上调用ready() 的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);
         }
      }));

这与 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 -> {
                    //...
                }
            }
        }
    })
}