Interfaces & Default Methods in Kotlin

Interfaces in Kotlin define a contract for classes, specifying functions and properties that must be implemented. Unlike Java 7, Kotlin interfaces can also provide default implementations, allowing behavior reuse without requiring inheritance.

1. Why Interfaces & Default Methods Matter

• Behavior abstraction: Define capabilities that multiple classes can implement, regardless of their position in the class hierarchy.
• Code reuse: Default methods allow sharing common behavior across multiple classes without duplication.
• Multiple behavior inheritance: Classes can implement multiple interfaces safely, avoiding the diamond problem seen in multiple class inheritance.
• Decoupling: Interfaces allow classes to depend on abstract behavior rather than concrete implementations.

2. What is an Interface?

An interface is a collection of abstract methods and properties that a class must implement. It defines what a class should do, not how.

2.1 Basic Interface Example

interface Flyable {
    fun fly()
}

class Bird : Flyable {
override fun fly() {
println("Bird is flying")
}
}

fun main() {
val bird = Bird()
bird.fly()
} 

Output:

Bird is flying
  

3. Default Methods in Interfaces

Kotlin allows you to provide a default implementation in an interface. Classes implementing the interface can reuse it or override it if needed.

3.1 Example: Default Method

interface Movable {
    fun move() {
        println("Moving by default behavior")
    }
}

class Car : Movable {
// Reuses default implementation
}

class Bike : Movable {
override fun move() {
println("Bike moves differently")
}
}

fun main() {
val car = Car()
val bike = Bike()
car.move()   // Uses default method
bike.move()  // Uses overridden method
} 

Output:

Moving by default behavior
Bike moves differently
  

4. Difference Between Interface Default Methods and Class Methods

• Interface default method: Provides behavior only, cannot store state (no backing fields).
• Class method: Can access class properties and store state.

interface Flyer {
    val speed: Int
        get() = 100  // Computed property
}

class Jet : Flyer {
// Uses speed = 100 from interface getter
} 

5. Multiple Interfaces & Conflict Resolution (Diamond Problem)

A class can implement multiple interfaces. If two interfaces have methods with the same signature, Kotlin requires you to override the method and resolve the conflict explicitly.

interface Flyer {
    fun action() = println("Flying")
}

interface Mover {
fun action() = println("Moving")
}

class Drone : Flyer, Mover {
override fun action() {
super.action()  // Call Flyer’s version
super.action()  // Call Mover’s version
println("Drone executes both actions")
}
}

fun main() {
val drone = Drone()
drone.action()
} 

Output:

Flying
Moving
Drone executes both actions
  

6. Summary Table

7. Technical Interview Questions

• What is an interface in Kotlin?
  A contract that defines methods and properties a class must implement, optionally providing default implementations.
• Can interfaces have state in Kotlin?
  No, interfaces cannot have backing fields, but they can define properties with custom getters.
• What are default methods?
  Methods in interfaces with a pre-defined implementation that implementing classes can reuse or override.
• How does Kotlin handle multiple interfaces with same method signatures?
  You must explicitly override the method and use super<InterfaceName>.method() to resolve conflicts.
• Why use interfaces instead of abstract classes?
  Interfaces allow multiple behavior inheritance and are more flexible for decoupling code.

8. Key Takeaways

• Interfaces define a contract for behavior and can have default methods for code reuse.
• Kotlin supports multiple interfaces safely, resolving conflicts explicitly.
• Use interfaces to design flexible, decoupled, and reusable components.
• Default methods reduce code duplication while still allowing overriding when needed.
• Understand the difference between interface default methods (behavior only) and class methods (can have state).