Usage of Inheritance and Polymorphism in Kotlin

Kotlin stands out in modern software development with its strong object-oriented programming (OOP) features. Among these, the concepts of inheritance and polymorphism make code more flexible and reusable. In this article, we will examine the concepts of Kotlin inheritance and polymorphism from a technical perspective and explain them with practical code samples.

What is Inheritance in Kotlin?

Inheritance allows a class to inherit properties and methods from another class. In Kotlin, by default, all classes are final, meaning they cannot be inherited by another class. For inheritance, you must mark your base class with the open keyword:

open class Animal(val name: String) {
    open fun makeSound() {
        println("An undefined sound...")
    }
}

class Cat(name: String): Animal(name) {
    override fun makeSound() {
        println("�24name: Meow!")
    }
}

As you can see, the Animal base class is marked with open and the Cat class is derived from this class. Also, the makeSound() function is redefined in the subclass using override.

Flexibility with Polymorphism

Polymorphism means that an object can exhibit different behaviors through the same interface. In Kotlin, inheritance and polymorphism are often used together. A reference of the base class type can refer to an object of a subclass:

fun announceAnimalSound(animal: Animal) {
    animal.makeSound()
}

fun main() {
    val animals = listOf(Animal("Animal"), Cat("Kitty"))
    for (animal in animals) {
        announceAnimalSound(animal)
    }
}

In this example, the announceAnimalSound function calls the correct function regardless of which subclass the objects belonging to the base class type actually come from — this is where polymorphism steps in. Thanks to Kotlin inheritance and polymorphism, common behaviors can be implemented in different ways.

Polymorphism with Interfaces in Kotlin

In Kotlin, inheritance is not limited to classes only. You can also achieve polymorphism using interface. Let's look at the following example:

interface Runnable {
    fun run()
}

class Car: Runnable {
    override fun run() {
        println("The car is running...")
    }
}

class Plane: Runnable {
    override fun run() {
        println("The plane is taking off...")
    }
}

In this structure, the Runnable interface has been implemented in different ways by different classes to achieve polymorphism.

Conclusion: Kotlin Inheritance and Polymorphism

The concepts of Kotlin inheritance and polymorphism make your code modular, flexible, and readable. To increase abstraction and code reusability, you should definitely use inheritance and polymorphism effectively in your projects. It is possible to create polymorphic solutions with both classes and interfaces. With these powerful OOP features of Kotlin, you can add value to modern software.