Using default function implementation of interface in Kotlin

user_922584 0
Viewed 39946

I have a Kotlin interface with a default implementation, for instance:

interface Foo {
    fun bar(): String {
        return "baz"
    }
}

This would be okay until I try to implement this interface from Java. When I do, it says the class need to be marked as abstract or implement the method bar(). Also when I try to implement the method, I am unable to call super.bar().

kotlin
5 Answers

Generating true default methods callable from Java is an experimental feature of Kotlin 1.2.40.

You need to annotate the methods with the @JvmDefault annotation:

interface Foo {
    @JvmDefault
    fun bar(): String {
        return "baz"
    }
}

This feature is still disabled by default, you need to pass the -Xjvm-default=enable flag to the compiler for it to work. (If you need to do this in Gradle, see here).

It really is experimental, however. The blog post warns that both design and implementation may change in the future, and at least in my IDE, Java classes are still marked with errors for not implementing these methods, despite compiling and working fine.

user_44652080

If you know you won't be overriding the function in any implementations of your interface, you can use extension functions as a nice workaround for this issue. Just put an extension function in the same file as the interface (and at the top level so other files can use it).

For example, what you're doing could be done this way:

interface Foo {
    // presumably other stuff
}

fun Foo.bar(): String {
    return "baz"
}

See the docs on extension functions for more information about them.

One "gotcha" worth noting:

We would like to emphasize that extension functions are dispatched statically, i.e. they are not virtual by receiver type. This means that the extension function being called is determined by the type of the expression on which the function is invoked, not by the type of the result of evaluating that expression at runtime.

Put simply, extension functions don't do what you might expect from regular polymorphism. What this means for this workaround is that the default function cannot be overridden like a regular function. If you try to override it, you'll get some weird behavior, because the "overridden" version will be called whenever you're dealing explicitly with the subclass, but the extension version will be called when you're dealing with the interface generically. For example:

interface MyInterface {
    fun a()
}

fun MyInterface.b() {
    println("MyInterface.b() default implementation")
}

class MyInterfaceImpl : MyInterface {
    override fun a() {
        println("MyInterfaceImpl.a()")
    }

    fun b() {
        println("MyInterfaceImpl.b() \"overridden\" implementation")
    }
}

fun main(args: Array<String>) {
    val inst1: MyInterface = MyInterfaceImpl()
    inst1.a()
    inst1.b() // calls the "default" implementation

    val inst2: MyInterfaceImpl = MyInterfaceImpl() // could also just do "val inst2 = MyInterfaceImpl()" (the type is inferred)

    inst2.a()
    inst2.b() // calls the "overridden" implementation
}
user_11247480

Since Kotlin 1.4.0, you can use one of the following compiler flags:

  • -Xjvm-default=all
  • -Xjvm-default=all-compatibility (for binary compatibility with old Kotlin code)

This will enable JVM default method compilation for all interfaces.

If you want to read up on how to set these flags in your IDE or Maven/Gradle project, check out the documentation on compiler options.

Progress on this is being tracked in issue KT-4779, which also includes a helpful summary of the current state. The @JvmDefault annotation and the older -Xjvm-default=enable and -Xjvm-default=compatibility compiler flags should no longer be used.

user_13916310
Related