Inheritance and Polymorphism in Kotlin: Bringing Classes to Life

Greetings! Today, we're going to demystify the crucial terms of Object-oriented programming (OOP): Inheritance and Polymorphism. These concepts form the backbone of efficient OOP. Our journey will unfold as follows: we'll start with an intuitive grasp of Inheritance and its implementation in Kotlin, and then we'll delve into Polymorphism, with a special focus on method overriding.

Inheritance is akin to repurposing an old blueprint to create something new. In OOP, it allows one class to inherit features (properties and functions) from another.

In Kotlin, we have the Parent Class (also known as Superclass), which provides features, and the Child Class (or Subclass), which receives these features. When implementing, we use the open keyword for the Parent Class (to allow inheritance), and the : symbol for the Child class indicates which Parent class the features are coming from.

// Defining an 'Animal' class (Parent Class). Marking it as 'open' allows other classes to inherit from it.
open class Animal {
    fun eat() {
        println("This animal eats food.") // Prints: "This animal eats food."
    }
}

// 'Cat' class inherits from 'Animal' (Child Class)
class Cat : Animal() {
    // Inherits all features from 'Animal'
}

val myCat = Cat()
myCat.eat() // Prints: "This animal eats food."

Inheritance in Kotlin involves subclasses inheriting features from their superclass. A crucial part of this process is ensuring that constructors in the superclass are properly invoked by the subclass. Constructors are special methods used to initialize new objects, and when a class inherits from another, the subclass must initialize the superclass as well, often providing the necessary parameters for any superclass constructor.

When a subclass inherits from a superclass, and both have primary constructors, the subclass's primary constructor needs to directly invoke the superclass's constructor. This ensures that any initial setup required by the superclass is performed:

open class Animal(val name: String) {
    init {
        println("$name is an Animal.")
    }
}

class Cat(name: String) : Animal(name) {
    init {
        println("$name is also a Cat.")
    }
}

fun main() {
    val myCat = Cat("Whiskers")
    // Output:
    // Whiskers is an Animal.
    // Whiskers is also a Cat.
}

In the above example, the Cat class inherits from Animal, and both classes have primary constructors that accept a name parameter. The Cat class passes this parameter to the Animal class's constructor using the : symbol followed by Animal(name), ensuring proper initialization.

For classes with secondary constructors, Kotlin requires that they either directly call the superclass constructor using super or delegate to another constructor in the same class that does:

open class Animal(val name: String)

class Cat : Animal {
    constructor(name: String, lives: Int) : super(name) {
        println("$name has $lives lives.")
    }
}

fun main() {
    val myCat = Cat("Felix", 9)
    // Output: Felix has 9 lives.
}

This setup, where a Cat class with a secondary constructor calls the superclass Animal constructor to ensure proper initialization, demonstrates the flexibility and power of Kotlin's inheritance mechanism. Understanding and applying constructor invocation correctly is essential for creating fully initialized, functional subclass objects in Kotlin, seamlessly extending the capabilities of the superclass.