How do I implement interfaces and use multiple inheritance in Kotlin?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, interfaces define a contract that classes can implement. Kotlin supports multiple inheritance of interfaces, but not multiple inheritance of classes.

1. Defining an interface

An interface can declare:

  • abstract properties
  • abstract functions
  • functions with default implementations
interface Drivable {
    val maxSpeed: Int

    fun drive()

    fun stop() {
        println("Stopping the vehicle")
    }
}

Here:

  • maxSpeed must be implemented by any class using the interface.
  • drive() has no body, so it must be implemented.
  • stop() has a default implementation, so overriding it is optional.

2. Implementing an interface

Use : after the class name to implement an interface.

class Car : Drivable {
    override val maxSpeed: Int = 180

    override fun drive() {
        println("The car is driving at up to $maxSpeed km/h")
    }
}

Usage:

fun main() {
    val car = Car()

    car.drive()
    car.stop()
}

Output:

The car is driving at up to 180 km/h
Stopping the vehicle

3. Implementing multiple interfaces

A class can implement more than one interface by separating them with commas.

interface Flyable {
    fun fly() {
        println("Flying")
    }
}

interface Swimmable {
    fun swim() {
        println("Swimming")
    }
}

class Duck : Flyable, Swimmable

Usage:

fun main() {
    val duck = Duck()

    duck.fly()
    duck.swim()
}

4. Handling conflicting default implementations

If two interfaces provide a function with the same signature, the implementing class must override it.

interface Printer {
    fun print() {
        println("Printing from Printer")
    }
}

interface Scanner {
    fun print() {
        println("Printing from Scanner")
    }
}

class AllInOneMachine : Printer, Scanner {
    override fun print() {
        super<Printer>.print()
        super<Scanner>.print()
        println("Printing from AllInOneMachine")
    }
}

Usage:

fun main() {
    val machine = AllInOneMachine()

    machine.print()
}

Output:

Printing from Printer
Printing from Scanner
Printing from AllInOneMachine

The syntax:

super<Printer>.print()

means “call the print() implementation from the Printer interface.”

5. Interfaces with properties

Interfaces can declare properties, but they do not store state directly like classes do.

interface Identifiable {
    val id: String
}

class User(
    override val id: String,
    val name: String
) : Identifiable

Usage:

fun main() {
    val user = User("u123", "Alice")

    println(user.id)
    println(user.name)
}

6. Kotlin and multiple inheritance

Kotlin allows:

class Duck : Flyable, Swimmable

But Kotlin does not allow multiple class inheritance:

open class Animal
open class Machine

// Not allowed in Kotlin
class RobotDog : Animal(), Machine()

Instead, Kotlin allows:

  • one superclass
  • multiple interfaces
open class Animal {
    fun eat() {
        println("Eating")
    }
}

interface Runnable {
    fun run()
}

interface Trainable {
    fun train()
}

class Dog : Animal(), Runnable, Trainable {
    override fun run() {
        println("Dog is running")
    }

    override fun train() {
        println("Dog is training")
    }
}

Key syntax

class ClassName : InterfaceName

class ClassName : InterfaceOne, InterfaceTwo

class ClassName : SuperClass(), InterfaceOne, InterfaceTwo

Summary

  • Use interface to define behavior.
  • Use : to implement interfaces.
  • Use override to implement interface members.
  • Kotlin supports multiple interface inheritance.
  • Kotlin does not support inheriting from multiple classes.
  • If interfaces have conflicting default methods, override the method and choose which parent implementation to call using super<InterfaceName>.

How do I use class inheritance with open and override in Kotlin?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, classes and members are final by default, so you must explicitly mark them as open if you want them to be inherited or overridden.

Basic class inheritance

open class Animal {
    open fun makeSound() {
        println("Some sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Bark")
    }
}

Usage:

fun main() {
    val dog = Dog()
    dog.makeSound()
}

Output:

Bark

Key rules

1. Use open on a class to allow inheritance

open class Animal

Without open, this is not allowed:

class Dog : Animal()

because Animal would be final by default.

2. Use open on functions or properties to allow overriding

open fun makeSound() {
    println("Some sound")
}

If a function is not marked open, subclasses cannot override it.

3. Use override in the subclass

override fun makeSound() {
    println("Bark")
}

Kotlin requires override so it is clear that you are replacing behavior from the parent class.

Inheriting from a class with a constructor

If the parent class has a constructor, the subclass must call it:

open class Animal(val name: String) {
    open fun introduce() {
        println("I am $name")
    }
}

class Dog(name: String) : Animal(name) {
    override fun introduce() {
        println("I am a dog named $name")
    }
}

Usage:

fun main() {
    val dog = Dog("Buddy")
    dog.introduce()
}

Output:

I am a dog named Buddy

Overriding properties

Properties can also be open and override:

open class Animal {
    open val sound: String = "Some sound"
}

class Dog : Animal() {
    override val sound: String = "Bark"
}

Usage:

fun main() {
    val dog = Dog()
    println(dog.sound)
}

Output:

Bark

Calling the parent implementation with super

You can call the superclass version using super:

open class Animal {
    open fun makeSound() {
        println("Some sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        super.makeSound()
        println("Bark")
    }
}

Output:

Some sound
Bark

Preventing further overriding

An overridden member is open by default. If you want to prevent subclasses from overriding it again, mark it as final:

open class Animal {
    open fun makeSound() {
        println("Some sound")
    }
}

open class Dog : Animal() {
    final override fun makeSound() {
        println("Bark")
    }
}

Now subclasses of Dog cannot override makeSound().

Summary

open class Parent {
    open fun method() {
        println("Parent method")
    }
}

class Child : Parent() {
    override fun method() {
        println("Child method")
    }
}
  • open class means the class can be inherited.
  • open fun or open val means the member can be overridden.
  • override means the subclass is replacing a parent member.
  • Use super.method() to call the parent version.

How do I use the init block to run setup logic in Kotlin classes?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, an init block runs setup logic when a class instance is created.

It is commonly used to validate constructor arguments, initialize derived properties, or perform other construction-time setup.

class User(val name: String, val age: Int) {

    init {
        require(name.isNotBlank()) {
            "Name must not be blank"
        }

        require(age >= 0) {
            "Age must be non-negative"
        }

        println("Created user: $name")
    }
}

Usage:

val user = User("Alice", 30)

When User("Alice", 30) is called, the init block runs automatically.

Key points

  • init blocks are part of the class initialization process.
  • They run after primary constructor parameters are available.
  • A class can have multiple init blocks.
  • Multiple init blocks run in the order they appear in the class body.
  • They are especially useful with primary constructors.

Example with multiple init blocks:

class Rectangle(val width: Int, val height: Int) {

    val area: Int

    init {
        require(width > 0) {
            "Width must be positive"
        }
    }

    init {
        require(height > 0) {
            "Height must be positive"
        }

        area = width * height
    }
}

You can also combine init blocks with property initializers:

class Product(val price: Double) {

    val tax = price * 0.2

    init {
        require(price >= 0) {
            "Price cannot be negative"
        }
    }
}

Initialization happens in the order the declarations appear in the class body, so property initializers and init blocks are executed top to bottom.

How do I override the toString(), equals(), and hashCode() methods in Kotlin?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, you usually don’t manually override toString(), equals(), and hashCode() if your class is just a value/data holder. Use a data class instead.

data class User(
    val id: Int,
    val name: String
)

Kotlin automatically generates:

toString()
equals()
hashCode()
copy()
componentN()

Example:

val a = User(1, "Alice")
val b = User(1, "Alice")

println(a)        // User(id=1, name=Alice)
println(a == b)   // true
println(a.hashCode() == b.hashCode()) // true

Manual override

If you need custom behavior, override them explicitly:

class User(
    val id: Int,
    val name: String
) {
    override fun toString(): String {
        return "User(id=$id, name=$name)"
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is User) return false

        return id == other.id && name == other.name
    }

    override fun hashCode(): Int {
        var result = id
        result = 31 * result + name.hashCode()
        return result
    }
}

Important notes

Use == for equality in Kotlin:

a == b

This calls equals() internally.

Use === for reference equality:

a === b

This checks whether both variables point to the exact same object.

Custom equality example

Sometimes you only want equality based on one property, such as id:

class User(
    val id: Int,
    val name: String
) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is User) return false

        return id == other.id
    }

    override fun hashCode(): Int {
        return id
    }

    override fun toString(): String {
        return "User(id=$id, name=$name)"
    }
}

The key rule is: if you override equals(), you should also override hashCode() consistently. Objects that are equal must have the same hash code.

How do I use data classes in Kotlin to store structured data?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, data classes are designed to store structured data with minimal boilerplate.

A data class automatically provides useful functions such as:

  • toString()
  • equals()
  • hashCode()
  • copy()
  • component functions for destructuring, like component1(), component2()

Basic example

data class User(
    val id: Int,
    val name: String,
    val email: String
)

You can create and use it like this:

fun main() {
    val user = User(
        id = 1,
        name = "Alice",
        email = "[email protected]"
    )

    println(user)
}

Output:

User(id=1, name=Alice, [email protected])

Accessing properties

println(user.name)
println(user.email)

Because the properties are declared in the primary constructor, they are available directly.

Comparing data objects

Data classes compare values, not object references:

val user1 = User(1, "Alice", "[email protected]")
val user2 = User(1, "Alice", "[email protected]")

println(user1 == user2) // true

Copying with changes

Use copy() to create a modified copy:

val updatedUser = user.copy(email = "[email protected]")

println(updatedUser)

The original object is unchanged.

Destructuring

Data classes support destructuring declarations:

val (id, name, email) = user

println(id)
println(name)
println(email)

Mutable vs immutable properties

Prefer val for immutable data:

data class Product(
    val id: Long,
    val name: String,
    val price: Double
)

Use var only if the property needs to change:

data class MutableUser(
    var name: String,
    var age: Int
)

Example with nested structured data

data class Address(
    val street: String,
    val city: String,
    val postalCode: String
)

data class Customer(
    val id: Int,
    val name: String,
    val address: Address
)

fun main() {
    val customer = Customer(
        id = 100,
        name = "Maria",
        address = Address(
            street = "Main Street",
            city = "Berlin",
            postalCode = "10115"
        )
    )

    println(customer.address.city)
}

Important rules

A Kotlin data class must:

  • Have at least one parameter in the primary constructor
  • Mark primary constructor parameters with val or var
  • Not be abstract, open, sealed, or inner

Example:

data class Book(
    val title: String,
    val author: String,
    val year: Int
)

Use data classes when you mainly need a class to hold data rather than define complex behavior.