Polymorphism in Kotlin: Dynamic and Static Examples

Greetings! In today's lesson, we'll unravel the concept of polymorphism in Kotlin's Object-Oriented Programming (OOP). Grasping polymorphism enables us to use a single entity (a method, class, or interface) to represent different types in various scenarios. Let's proceed.

Polymorphism, a pillar of OOP, allows one object to embody multiple forms. Visualize a button in software; depending on its type (for instance, a submit button or a radio button), the action resulting from pressing it varies. This dynamic encapsulates the spirit of polymorphism!

Kotlin supports various types of polymorphism. Run-time polymorphism, also known as dynamic polymorphism, occurs during runtime and leverages method overriding. Let's observe dynamic polymorphism in action within a simple application involving shapes. The base Shape class has an area method, which calculates the area for shapes. This method is uniquely implemented in the subclasses Rectangle and Circle.

abstract class Shape {
    abstract fun area(): Double
}

class Rectangle(private val length: Double, private val width: Double) : Shape() {
    override fun area(): Double {
        return length * width
    }
}

class Circle(private val radius: Double) : Shape() {
    override fun area(): Double {
        return Math.PI * radius * radius
    }
}

fun main() {
    val rectangle: Shape = Rectangle(2.0, 3.0)
    println(rectangle.area()) // Prints: 6.0

    val circle: Shape = Circle(5.0)
    println(circle.area()) // Prints: 78.5
}

Here, polymorphism shines as the area() method takes on multiple forms while using the same Shape abstract class. It behaves differently depending on whether the object is a Rectangle or a Circle.

Another type of polymorphism that Kotlin supports is compile-time polymorphism, also known as static polymorphism, which operates during compile time and involves method overloading. Let's look at the example of static polymorphism:

class MathOperations {
    // Overloaded method for rectangle area
    fun area(length: Double, width: Double): Double {
        return length * width
    }

    // Overloaded method for circle area
    fun area(radius: Double): Double {
        return Math.PI * radius * radius
    }
}

fun main() {
    val mathOps = MathOperations()
    println(mathOps.area(5.0, 2.0)) // Rectangle area
    println(mathOps.area(3.0))      // Circle area
}

In this example, polymorphism is demonstrated via method overloading. The area method has multiple forms, accepting different parameter lists to compute the area of either a rectangle or a circle based on the provided arguments. This is a clear example of static polymorphism, where the correct method is determined at compile time.