Kotlin Interfaces – Complete Guide with Examples (2025)

Understand how interfaces work in Kotlin, how they differ from abstract classes, and how to implement multiple interfaces with real code examples.

What is an Interface in Kotlin?

An interface in Kotlin defines a contract that classes can implement. It can contain:

• Abstract methods (without implementation)
• Concrete methods (with default implementation) — from Kotlin 1.1+
• Properties (abstract or with getters)

Use interfaces when you want to define capabilities that can be shared across unrelated classes.

Kotlin Interface Syntax

interface Drivable {
    fun drive()
    fun stop() {
        println("Vehicle stopped.")
    }
}

• drive() is abstract.
• stop() has a default implementation.

Implementing an Interface

class Car : Drivable {
    override fun drive() {
        println("Driving the car...")
    }
}

fun main() {
    val myCar = Car()
    myCar.drive()      // Output: Driving the car...
    myCar.stop()       // Output: Vehicle stopped.
}

The class must override all abstract methods in the interface.

Multiple Interfaces

Kotlin supports multiple interface inheritance, enabling classes to implement multiple behaviors:

interface Drivable {
    fun drive()
}

interface Flyable {
    fun fly()
}

class FlyingCar : Drivable, Flyable {
    override fun drive() = println("FlyingCar is driving.")
    override fun fly() = println("FlyingCar is flying.")
}

This allows composition of behaviors, similar to mixins.

Interfaces with Properties

interface Shape {
    val name: String
    fun draw()
}

class Circle : Shape {
    override val name = "Circle"
    override fun draw() = println("Drawing a circle.")
}

• Properties can be declared in interfaces.
• Must be overridden or have a default getter.

🤺 Interface Inheritance

Interfaces can extend other interfaces:

interface Machine {
    fun operate()
}

interface SmartMachine : Machine {
    fun selfCheck()
}

A class implementing SmartMachine must also implement operate().

Interface vs Abstract Class – Quick Comparison

Summary

FAQ – Kotlin Interfaces

Q1: Can an interface have a constructor?

A: No. Interfaces in Kotlin cannot have constructors or state (fields).

Q2: Can you inherit from multiple interfaces in Kotlin?

A: Yes. Kotlin supports multiple interface inheritance.

Q3: Can you override default methods in interfaces?

A: Yes. Classes can override default methods provided in interfaces.

interface Greetable {
    fun greet() = println("Hello!")
}

class User : Greetable {
    override fun greet() = println("Hi there!")
}

Q4: Can interfaces contain properties?

A: Yes, but:

• They must be abstract, or
• Have only getter implementations.

Q5: Is interface the same as abstract class?

A: No. Use interface for defining capabilities and abstract class for shared code base and inheritance.