CODEWITHSUNDEEP
interfacekotlinabstract
bitvale
bitvale

Reputation: 2079

Kotlin abstract method with body

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?

Upvotes: 4

Views: 8168

Answers (1)

zsmb13
zsmb13

Reputation: 89538

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).

Upvotes: 9

Related Questions