Introduction to Polymorphism in Kotlin

Welcome back! We're continuing our journey into object-oriented programming (OOP) with a new and exciting topic: Polymorphism. You've already learned about classes, objects, and inheritance, which are essential building blocks of OOP. Now it's time to explore how polymorphism can make your code more flexible and reusable.

Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. This provides a way to use a single interface to represent different types of objects. Here’s what we’ll cover in this lesson:

1. Understanding Polymorphism: We'll discuss what polymorphism is and why it's a powerful concept in Kotlin programming.
2. Runtime Polymorphism: You'll learn how to use interfaces and method overriding to achieve runtime polymorphism.
3. Compile-Time Polymorphism: You'll understand method overloading and how it's used for compile-time polymorphism.

Polymorphism in Kotlin allows you to call derived class methods through a base class or interface reference. This can make your code more dynamic and general. Polymorphism in Kotlin can be achieved through two distinct methods:

• Method Overriding (Runtime Polymorphism): This is when a subclass provides a specific implementation of a method that is already defined in its superclass. In Kotlin, you use the open modifier for methods in the superclass that you want to allow to be overridden, and you use the override modifier in the subclass.
• Method Overloading (Compile-Time Polymorphism): This is when multiple methods in the same class have the same name but different parameters. They may have different return types, but using different parameter lists allows Kotlin to distinguish between them.

Polymorphism enables a single action to be performed in different ways. The ability to redefine functions in derived classes and have a unified method call mechanism via base classes or interfaces is a strength of Kotlin OOP.

Runtime polymorphism is achieved through method overriding. Here are the rules for method overriding:

1. Same Method Signature: The function in the derived class must have the same name, return type, and parameters as the function in the base class.
2. Inheritance: The class must be a subclass of the base class where the original function is defined.
3. Access Modifier: The overriding function cannot have a more restrictive access modifier than the function in the base class.
4. Invocation: The Kotlin runtime determines which function to invoke based on the object's actual class, not the reference type.
5. Annotations: It's a good practice to use the @Override annotation to ensure that you are indeed overriding a method.

Example:

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

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

class Cat : Animal() {
    override fun sound() {
        println("Cat meows")
    }
}

fun main() {
    val myDog: Animal = Dog()
    myDog.sound()  // Output: Dog barks

    val myCat: Animal = Cat()
    myCat.sound()  // Output: Cat meows
}

In this example, the sound function in Dog and Cat overrides the sound function in Animal. When sound is called on the Animal reference pointing to a Dog or Cat object, the respective sound function of Dog or Cat is invoked.