Kotlin abstract method with body

user_5417224 0
Viewed 6201

As mention here: if a function in an interface has no body it is abstract by default. But there is nothing about interface's function with body.

Example:

interface MyInterface {
    fun foo() { print("Something") }
    fun bar()
}

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

Output will be:

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

How it's possible, that method with defined body is abstract?

kotlin abstract interface
1 Answers

This has to do with the way default methods in Kotlin interfaces are implemented. The foo and bar methods in your interface really are both abstract.

However, there is an inner class inside the interface that looks something like this (simplified):

public interface MyInterface {
   void foo();
   void bar();

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

This class is the one that contains the default implementations of any functions that you gave a body to inside the interface.

Then, if you create a class that implements this interface, and you don't override the foo method:

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

Then you get one generated automatically, which just calls the implementation inside DefaultImpls:

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

You can find all these details by using the bytecode viewer that comes with the Kotlin plugin (Tools -> Kotlin -> Show Kotlin Bytecode, and then the Decompile option).

user_44652080
Related