Polymorphism for Backward Compatibility in Kotlin

Hello, learner! In today's exciting chapter, we will unravel Polymorphism, a prominent feature of Object-Oriented Programming (OOP). Specifically, we will study its role in maintaining backward compatibility while introducing new features. Think of it as a software update that introduces new functions without breaking the older functionality — ingenious, isn't it?

Polymorphism, a principle that derives from the Greek words "poly" (many) and "morphism" (forms), enables a variable or method to assume multiple roles — to embody various behaviors or functions determined by its data type or class.

Consider an open class Bird with a method canFly(). If we create subclasses like Sparrow and Penguin, we can override the canFly() method for certain subclasses. This demonstrates polymorphism in action.

open class Bird {  // Superclass
    open fun canFly(): String {
        return "Unknown"
    }
}

class Sparrow : Bird() {  // Subclass
    override fun canFly(): String {
        return "Yes, I can fly!"
    }
}

class Penguin : Bird() {  // Subclass
    override fun canFly(): String {
        return "No, I prefer swimming."
    }
}

fun main() {
    val sparrow = Sparrow()
    val penguin = Penguin()
    println("Sparrow says: ${sparrow.canFly()}")  // Output: "Yes, I can fly!"
    println("Penguin says: ${penguin.canFly()}")  // Output: "No, I prefer swimming."
}

When adding new features, which introduce new behaviors to some components, polymorphism ensures that the existing parts function as before, thereby retaining backward compatibility. In complex cases, we maintain an older version of the method in the superclass for legacy support while offering newer functionalities in subclasses.

Take, for instance, a MathOperations class with a multiply() method that accepts two parameters. To support the multiplication of three numbers, we design a subclass, ExtendedMathOperations, and include a new overloaded multiply() method in it, ensuring backward compatibility.

open class MathOperations {  // Superclass
    open fun multiply(a: Int, b: Int): Int {
        return a * b
    }
}

class ExtendedMathOperations : MathOperations() {  // Subclass
    override fun multiply(a: Int, b: Int): Int {
        return a * b
    }

    fun multiply(a: Int, b: Int, c: Int): Int {
        return a * b * c
    }
}

fun main() {
    val mathOps = MathOperations()
    val extendedMathOps = ExtendedMathOperations()
    println(mathOps.multiply(2, 3))  // Output: 6
    println(extendedMathOps.multiply(2, 3))  // Output: 6, keeping backward compatibility
    println(extendedMathOps.multiply(2, 3, 4))  // Output: 24
}