Inheritance & Interfaces

Reviewed & published by Brayan K

Kotlin is a modern, concise language that supports object-oriented design through inheritance and interfaces — but with safe defaults, since classes are final unless you opt in with open.

Part of the free Kotlin course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

By the end of this lesson you'll build class hierarchies, override methods polymorphically, and implement interfaces and abstract classes.

What You'll Learn in This Lesson

• Why classes are final and how open works
• Subclassing with : and override
• Polymorphism via overridden methods
• Declaring and implementing interfaces
• Default methods in interfaces
• Abstract classes and when to use them

1️⃣ Inheritance and Overriding

In Kotlin, classes and methods are final by default. To allow a subclass, mark the class open; to allow overriding a method, mark it open too. A subclass inherits with : and replaces behaviour with override.

// Classes are FINAL by default. Mark a class 'open' to allow subclassing,
// and 'open' a function to allow overriding it.
open class Animal(val name: String) {
    open fun speak(): String = "...some sound..."
    fun describe(): String = "$name says ${speak()}"
}

// A subclass uses ':' to inherit, and 'override' to replace a method.
class Dog(name: String) : Animal(name) {
    override fun speak(): String = "Woof"
}

class Cat(name: String) : Animal(name) {
    override fun speak(): String = "Meow"
}

fun main() {
    val animals = listOf(Dog("Rex"), Cat("Lily"), Animal("Mystery"))
    for (a in animals) {
        println(a.describe())   // polymorphism: the right speak() is chosen
    }
}

This is polymorphism: the loop calls describe() on each animal, and the correct speak() runs depending on the actual type.

2️⃣ Interfaces and Abstract Classes

An interface defines a contract and may include default implementations. An abstract class can hold state and mix concrete with abstract members. A class can implement many interfaces but extend only one class.

// An interface declares a contract; classes implement it.
interface Drivable {
    val maxSpeed: Int                 // abstract property
    fun drive(): String               // abstract method
    fun honk(): String = "Beep!"      // default implementation
}

// An abstract class can hold state AND abstract members.
abstract class Vehicle(val wheels: Int) {
    abstract fun kind(): String
}

class Car : Vehicle(4), Drivable {    // extend a class AND an interface
    override val maxSpeed = 120
    override fun kind() = "Car"
    override fun drive() = "Driving a ${kind()} at $maxSpeed km/h on $wheels wheels"
}

fun main() {
    val car = Car()
    println(car.drive())              // -> Driving a Car at 120 km/h on 4 wheels
    println(car.honk())               // default from interface -> Beep!
}

Car extends an abstract Vehicle and implements Drivable — and gets honk() free from the interface's default.

Your turn. Replace the TODO, then run and compare.

// 🎯 YOUR TURN — replace each TODO then run main()

open class Shape {
    open fun area(): Double = 0.0
}

// 1) Make Square inherit from Shape and override area().
class Square(val side: Double) : Shape() {
    TODO fun area(): Double = side * side   // 👉 replace TODO with 'override'
}

class Circle(val radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
}

fun main() {
    val shapes: List<Shape> = listOf(Square(3.0), Circle(1.0))
    for (s in shapes) {
        println("%.2f".format(s.area()))
    }
    // ✅ Expected:
    //    9.00
    //    3.14
}

Mini-Challenge: A Notification System

Define one interface and two implementations, then treat them polymorphically through the interface type.

// 🎯 MINI-CHALLENGE: a notification system.
// Save as Notify.kt and run main().
//
// 1. Define interface Notifier with fun send(message: String): String.
// 2. Make class EmailNotifier implement it, returning
//    "Email: <message>".
// 3. Make class SmsNotifier implement it, returning
//    "SMS: <message>".
// 4. In main(), put both in a List<Notifier>, loop over them,
//    and print send("Hello") for each.
//
// ✅ Example output:
//    Email: Hello
//    SMS: Hello

fun main() {
    // your code here
}

Common Errors (and the fix)

• "This type is final, so it cannot be inherited" — Mark the base class open.
• "... is final and cannot be overridden" — Mark the base method open too.
• Forgetting override — Replacing a method requires the override keyword.
• Calling a base constructor wrong — Pass arguments to the superclass: class Dog(name: String) : Animal(name).

Pro Tips

• 💡 Prefer interfaces for capabilities; reserve inheritance for true "is-a" relationships.
• 💡 Call the parent with super.method() when you want to extend, not fully replace, behaviour.
• 💡 Favour composition: sometimes holding an object is cleaner than inheriting from it.

📋 Quick Reference — Inheritance

🎉 Lesson Complete!

• ✅ Classes are final by default — use open to allow subclassing
• ✅ Subclass with : and replace methods with override
• ✅ Polymorphism picks the right override at runtime
• ✅ Interfaces define contracts and can have default methods
• ✅ Abstract classes hold state; a class extends only one

Practice quiz

Continue this course

• Previous: Data Classes
• Next: Sealed Classes & Enums — Model restricted type hierarchies with sealed classes and enums
• Quick reference: Kotlin cheat sheet › Classes & Objects

Frequently asked questions

Why are Kotlin classes final by default?

Kotlin makes classes and methods final (non-inheritable, non-overridable) unless you explicitly mark them open. This follows the principle 'design for inheritance or prohibit it' — uncontrolled subclassing can break a class in subtle ways. Requiring open forces you to consciously decide which classes and methods are meant to be extended, leading to safer, more intentional hierarchies. To allow subclassing, write open class; to allow overriding a method, write open fun.

What is the difference between an interface and an abstract class?

An interface defines a contract — a set of methods and properties a class promises to provide — and can include default method implementations, but it cannot hold mutable state (no backing fields). An abstract class can hold state, have constructors, and mix concrete and abstract members, but a class can extend only one of them. Use an interface to describe a capability that many unrelated classes can share, and an abstract class when you want to share state and base behaviour within a single hierarchy. A class can implement many interfaces but extend only one class.

What does polymorphism mean here?

Polymorphism means a single piece of code can work with objects of many related types, and the correct overridden behaviour is chosen at runtime. In the example, looping over a List<Animal> and calling speak() invokes Dog's version for a Dog and Cat's for a Cat, even though the loop only knows they are Animals. This lets you write general code against a base type and have specialised subclasses fill in the details.

Can interfaces have default implementations?

Yes. An interface method can provide a default body, as honk() does in the example, so implementing classes inherit that behaviour for free and only override it when they need something different. Interfaces can also declare abstract properties (without backing fields) and properties with custom getters. What they cannot do is store state in a backing field, which is the main thing reserved for classes.