Introduction to Polymorphism in JavaScript

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 or prototype rather than their actual class. JavaScript provides polymorphism using dynamic typing and prototype-based inheritance. 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 JavaScript programming.
2. Prototype Inheritance: You'll learn how JavaScript uses prototypes and inheritance to achieve polymorphism.

Polymorphism in JavaScript allows you to call methods on derived objects through a reference to their base class or prototype. This approach makes your code more dynamic and general. JavaScript achieves polymorphism primarily through the following method:

• Prototype-Based Inheritance: JavaScript uses prototypes for inheritance, which allows different objects to simulate polymorphism by having shared behavior through their prototype chain.

Polymorphism enables a single action to be defined in different ways. The capability to redefine methods across various objects sharing the same prototype is a strength of JavaScript OOP.

JavaScript uses prototype inheritance to achieve polymorphism. Here are the rules for achieving polymorphism using prototypes:

1. Method Overriding via Prototypes: Derived objects can override methods defined on their prototype objects. This is similar to the concept of method overriding in other languages.
2. Prototype Chain: When a method is called on an object, JavaScript first looks for this method on the object. If not found, it continues up the prototype chain until it finds the method or reaches the end of the chain.
3. Dynamic Typing: JavaScript's dynamic typing allows the redefinition of methods in different objects that share a common interface or prototype.
4. Function Context: JavaScript functions have dynamic contexts, determined at runtime. This allows methods to operate based on the actual object invoking them.

Example:

class Animal {
    sound() {
        console.log("Animal makes a sound");
    }
}

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

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

function playSound(animal) {
    animal.sound();
}

const myDog = new Dog();
playSound(myDog);  // Output: Dog barks

const myCat = new Cat();
playSound(myCat);  // Output: Cat meows

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