Why open keyword is required for inheritance in Kotlin - The Real Reasons

The Big Idea

What if your code could protect itself from accidental changes while still letting you build on it easily?

The Scenario

Imagine you have a class in Kotlin that you want to reuse and add new features to by creating a child class. But when you try to inherit from it, the compiler stops you. This feels like trying to build a new room on a house that was never designed to be expanded.

The Problem

Without the open keyword, Kotlin classes are final by default. This means you cannot inherit from them. Trying to do so causes errors, making it frustrating to extend functionality or reuse code. It forces you to rewrite or duplicate code instead of building on what exists.

The Solution

The open keyword in Kotlin explicitly marks a class as inheritable. It tells the compiler, "This class is designed to be extended." This clear signal prevents accidental inheritance and makes your code safer and easier to maintain.

Before vs After

✗ Before

class Animal {
    fun sound() = println("Some sound")
}

class Dog : Animal() {} // Error: Cannot inherit from final class

✓ After

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

class Dog : Animal() {
    fun bark() = println("Woof")
}

What It Enables

Using open lets you safely create new classes that build on existing ones, enabling flexible and reusable code design.

Real Life Example

Think of a video game where you have a basic Character class. Marking it open allows you to create specialized characters like Wizard or Warrior that inherit common traits but add unique abilities.

Key Takeaways

Kotlin classes are final by default to prevent unintended inheritance.

The open keyword explicitly allows a class to be inherited.

This approach improves code safety and clarity while enabling reuse.