What is Inheritance? Understanding the Basics in Kotlin

Inheritance is a fundamental concept in object-oriented programming that allows a class to inherit the properties and methods of another class, facilitating code reusability and the extension of existing functionalities. In Kotlin, inheritance is used to create a new class called a subclass that is based on an existing class called a superclass.

Understanding Inheritance in Kotlin

In Kotlin, to declare a class as inheritable, you must mark it with the open keyword. By default, all classes in Kotlin are final, which means they cannot be inherited unless explicitly specified as open.

Superclass Declaration

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

In this example, Animal is a superclass with an open method sound(). This method can be overridden by any subclass.

Subclass Declaration

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

The class Dog inherits from Animal and overrides the sound() method to provide its own implementation.

Using Subclasses

fun main() {
    val myDog: Animal = Dog()
    myDog.sound()  // Outputs: Bark
}

Here, we instantiate Dog but reference it as an Animal. When we call the sound() method, the overridden version in Dog gets executed, producing an output of Bark.

Key Points to Remember

• Use the open keyword to make a class or method inheritable.
• Use the override keyword to provide a specific implementation for a superclass's method in a subclass.
• Kotlin supports single inheritance, where a subclass can have only one direct superclass. However, Kotlin supports interfaces to allow multiple inheritance-like behavior.

Benefits of Using Inheritance

Inheritance supports a hierarchical classification where you can:

• Reduce code redundancy by reusing code in derived classes.
• Enhance code readability and organization.
• Effectively implement polymorphic behavior.