Polymorphism in Scala: Unifying Flexibility and Reusability

Welcome to the last lesson in our course about "Revisiting OOP Concepts in Scala"! 🔥 After navigating through the fascinating landscapes of classes, encapsulation, inheritance, abstract classes and traits, it's time to unlock one of the most captivating principles of Object-Oriented Programming (OOP): polymorphism. This very useful concept elevates your code to new heights by allowing different classes to be manipulated through a common interface, infusing flexibility and a touch of magic into your developer's toolkit.

Imagine a grand orchestra where various instruments play unique melodies, yet harmonize through a single musical score. That's polymorphism in the programming world! At its core, polymorphism enables objects of different subclasses to be treated as objects of their superclass. This means you can write code using references to a superclass, but behind the scenes, the actual objects might belong to any subclass of that superclass.

When you invoke a method on a superclass reference, the program decides at runtime which subclass implementation to execute. This powerful concept simplifies code management, enhances flexibility, and allows your applications to be more dynamic and scalable. It's like having a universal remote that can control any device—convenient and efficient!

Enough theory—let's witness polymorphism flex its muscles in Scala! We'll explore how to implement it using abstract classes and method overriding.

// Define an abstract class Person with name and age attributes
abstract class Person(val name: String, val age: Int):
  def display(): Unit =
    println(s"Name: $name, Age: $age")

// Define a derived class Student with a major attribute
class Student(name: String, age: Int, val major: String) extends Person(name, age):
  override def display(): Unit =
    super.display()
    println(s"Major: $major")

// Define a derived class Teacher with a subject attribute
class Teacher(name: String, age: Int, val subject: String) extends Person(name, age):
  override def display(): Unit =
    super.display()
    println(s"Subject: $subject")

@main def main(): Unit =
  // Create a list of Person references encompassing Student and Teacher objects
  val people: List[Person] = List(
    Student("Alice", 30, "Computer Science"),
    Teacher("Bob", 25, "Mathematics")
  )

  // Use polymorphism to call display on each object in the list
  people.foreach(_.display())

In this code snippet, the display method in Student and Teacher classes overrides the base class method defined in Person. When we call display on each element in the people list, Scala dynamically invokes the appropriate method depending on the object's actual class: the super.display() call ensures that the base class method is executed first, and then the specific behavior of the subclass is added on top of that. The people list holds references of type Person, but the actual objects are instances of Student and Teacher. This is polymorphism in action!

When you run this code, you'll see that each object's specific display method is executed:

Name: Alice, Age: 30
Major: Computer Science
Name: Bob, Age: 25
Subject: Mathematics