When a Kotlin interface has a method with a body (a default implementation), how is that body compiled for the JVM by default, and what is the DefaultImpls class?
answer
- Interface body -> DefaultImpls static method
- Receiver passed as first arg ($this)
- JVM interface method stays abstract (legacy)
- Each impl class gets a delegating bridge
- -Xjvm-default switches strategy
basics
~20 sKotlin lets interface methods have a body. By default the compiler does not put that body on the JVM interface itself; it copies it into a hidden helper class so classes implementing the interface can reuse it.
solid answer
~40 sA Kotlin interface can declare method bodies. Historically the JVM had no default methods, so the Kotlin compiler emits the body into a synthetic nested class named DefaultImpls (e.g. MyInterface$DefaultImpls) as a static method taking the receiver as the first argument. The interface method itself stays abstract on the JVM. Each Kotlin class implementing the interface generates a bridge method that simply delegates to MyInterface$DefaultImpls.method(this, ...). This is why, with the legacy default, a Java class implementing the Kotlin interface does NOT inherit the body — it sees an abstract method and must implement it. The behavior is controlled by the -Xjvm-default compiler flag; -Xjvm-default=all makes Kotlin emit real JVM default methods instead.
code
kotlin · 12 linesinterface Greeter {
fun greet(): String = "hi"
}
// Conceptually the compiler (legacy mode) emits:
// public interface Greeter { String greet(); /* abstract on JVM */
// public static final class DefaultImpls {
// public static String greet(Greeter $this) { return "hi"; }
// }
// }
class En : Greeter // synthetic: String greet() { return Greeter.DefaultImpls.greet(this); }go deeper
Knows interfaces can have bodies and that a hidden helper class holds them.
Can name DefaultImpls, the static method with receiver-as-first-arg, and the bridge in implementors.
Explains the JVM-6-history rationale and the abstract-on-JVM interop consequence for Java.
Frames it as an ABI strategy and connects it to -Xjvm-default mode choices for library evolution.
## The feature Kotlin interfaces may contain **method bodies** (default implementations) and even default-implemented properties (without backing fields). On the source level this looks just like Java 8+ default methods. ## Why DefaultImpls exists Kotlin originally targeted **JVM 6**, which had no `default` methods on interfaces (those arrived in Java 8 bytecode). To still allow interface bodies, the compiler puts the code somewhere it is legal: a synthetic nested class. For an interface `Greeter` with `fun greet() = "hi"`, the compiler emits: - The interface `Greeter` with `greet()` left **abstract** on the JVM. - A nested class `Greeter$DefaultImpls` containing a **static** method `greet(Greeter $this)` that holds the actual body. The receiver is passed explicitly as the first parameter. Each Kotlin class that implements `Greeter` and does not override `greet` gets a generated **bridge** method whose body is `return Greeter$DefaultImpls.greet(this)`. ```kotlin interface Greeter { fun greet(): String = "hi" // body lives in Greeter$DefaultImpls } class En : Greeter // gets a synthetic greet() delegating to DefaultImpls ``` ## The interop consequence Because the JVM interface method is abstract, **Java code** implementing `Greeter` sees no inherited body and is forced to implement `greet()` itself. From Kotlin everything works as expected; the asymmetry only bites Java consumers. ## Controlling it The `-Xjvm-default` compiler flag changes the strategy: - `disable` (legacy default in older versions): DefaultImpls only. - `all`: emit **real JVM `default` methods** directly on the interface, so Java inherits the body. DefaultImpls largely disappears. - `all-compatibility`: emit real default methods **and** keep DefaultImpls for binary compatibility with already-compiled callers. Keywords to know: `-Xjvm-default`, `DefaultImpls`, synthetic static method, bridge method.
- Why was the receiver passed explicitly as the first parameter of the DefaultImpls method?DefaultImpls methods are plain static methods with no implicit `this`, so the interface instance must be threaded in manually to let the body call other members on `$this`.
- Does a Kotlin class implementing the interface ever need to do anything special to get the default?No. The compiler auto-generates the delegating bridge for any Kotlin implementor that doesn't override the method.
DefaultImpls is like a shared recipe card kept in a side drawer: each cook (class) copies it, but a Java cook who never opens that drawer has to write the recipe from scratch.
saying these in an interview costs you the question
- Claiming Kotlin always compiles interface bodies to real JVM default methods
- Saying Java automatically inherits the body in legacy mode
- Confusing DefaultImpls with companion objects
- Thinking the developer must write DefaultImpls by hand
- Not knowing a compiler flag controls the behavior