Método abstracto de Kotlin con cuerpo

Como menciono aquí : si una function en una interfaz no tiene cuerpo, es abstracta por defecto. Pero no hay nada sobre la function de la interfaz con el cuerpo.

Ejemplo:

interface MyInterface { fun foo() { print("Something") } fun bar() } fun main(args: Array<String>) { println(MyInterface::foo.javaMethod) println(MyInterface::bar.javaMethod) } 

La salida será:

 public abstract void MyInterface.foo() public abstract void MyInterface.bar() 

¿Cómo es posible, ese método con cuerpo definido es abstracto?

Esto tiene que ver con la forma en que se implementan los methods pnetworkingeterminados en las interfaces de Kotlin. Los methods foo y bar en su interfaz realmente son abstractos.

Sin embargo, hay una class interna dentro de la interfaz que se ve más o less así (simplificada):

 public interface MyInterface { void foo(); void bar(); public static final class DefaultImpls { public static void foo() { System.out.print("Something"); } } } 

Esta class es la que contiene las implementaciones pnetworkingeterminadas de cualquier function a la que haya asignado un cuerpo dentro de la interfaz.

Luego, si crea una class que implementa esta interfaz, y no anula el método foo :

 class MyClass: MyInterface { override fun bar() { println("MyClass") } } 

Luego obtienes uno generado automáticamente, que solo llama a la implementación dentro de DefaultImpls :

 public final class MyClass implements MyInterface { public void bar() { System.out.println("MyClass"); } public void foo() { MyInterface.DefaultImpls.foo(); } } 

Puede encontrar todos estos detalles utilizando el visor de códigos de bytes que viene con el complemento Kotlin ( Tools -> Kotlin -> Show Kotlin Bytecode , y luego la opción Decompile ).