Understanding JavaScript Polymorphism

Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows methods to perform different actions depending on the object they are acting upon. In JavaScript, polymorphism can be achieved through method overriding and method overloading. Below is a detailed breakdown of these key concepts:

Key Concepts

1. What is Polymorphism?

• Definition: Polymorphism means "many forms." It allows objects of different classes to be treated as objects of a common superclass.
• Purpose: This capability enables a single function or method to behave differently based on the object it is invoked on.

2. Types of Polymorphism

• Compile-time Polymorphism (Method Overloading):
  • This occurs when multiple functions share the same name but differ in parameters.
  • While JavaScript does not support traditional method overloading, similar results can be achieved using default parameters or type-checking of arguments.
• Run-time Polymorphism (Method Overriding):
  • This occurs when a subclass provides a specific implementation of a method already defined in its superclass.
  • It enables dynamic method resolution at runtime.

Examples

Method Overriding Example

class Animal {
    speak() {
        console.log("Animal speaks");
    }
}

class Dog extends Animal {
    speak() {
        console.log("Dog barks");
    }
}

class Cat extends Animal {
    speak() {
        console.log("Cat meows");
    }
}

const myDog = new Dog();
const myCat = new Cat();

myDog.speak(); // Output: Dog barks
myCat.speak(); // Output: Cat meows

Explanation: In this example, both the Dog and Cat classes override the speak method of the Animal class. When the speak method is called on each object, the respective implementation is executed.

Method Overloading Alternative Example

function add(a, b) {
    return a + b;
}

// Using the same function name with different types
console.log(add(5, 10));   // Output: 15
console.log(add("Hello, ", "World!")); // Output: Hello, World!

Explanation: Although JavaScript does not support traditional method overloading, you can create functions that handle different types of inputs, providing similar functionality.

Conclusion

• Polymorphism is a crucial concept in JavaScript that enhances code flexibility and reusability.
• It allows different classes to define methods that can be called using the same name, facilitating diverse behavior in a consistent manner.
• Understanding polymorphism is key to building scalable and maintainable applications.