Polymorphism JavaScript Object-Oriented Programming (OOP)

Edit Copy Hide

class Animal {
  speak() {
    console.log('The animal makes a sound.');
  }
}

class Cat extends Animal {
  speak() {
    console.log('Meow!');
  }
}

const animal = new Animal();
const cat = new Cat();

animal.speak(); // Output: The animal makes a sound.
cat.speak(); // Output: Meow!

Explanation: In this example, the Animal class has a speak method that prints a generic sound. The Cat class extends Animal and overrides the speak method with its own implementation. When speak is called on an instance of Animal, it uses the method from the Animal class, while calling it on an instance of Cat uses the method overridden in the Cat class. This demonstrates polymorphism through method overriding.

Edit Copy Hide

class Shape {
  getArea() {
    return 0;
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }

  getArea() {
    return Math.PI * Math.pow(this.radius, 2);
  }
}

function printArea(shape) {
  console.log(`Area: ${shape.getArea()}`);
}

const rectangle = new Rectangle(4, 5);
const circle = new Circle(3);

printArea(rectangle); // Output: Area: 20
printArea(circle); // Output: Area: 28.274333882308138

In this example, the printArea function takes a parameter shape, which can be an instance of any class that extends the Shape class. The getArea method is polymorphic, as its implementation differs depending on the specific class (e.g., Rectangle or Circle). When printArea is called with an instance of Rectangle or Circle, it invokes the appropriate getArea method based on the object's type.

Edit Copy Hide

class Animal {
  constructor(name) {
    this.name = name;
  }

  makeSound() {
    // Abstract method
  }
}

class Dog extends Animal {
  makeSound() {
    console.log('Woof!');
  }
}

class Cat extends Animal {
  makeSound() {
    console.log('Meow!');
  }
}

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

const dog = new Dog('Buddy');
const cat = new Cat('Whiskers');

playSound(dog); // Output: Woof!
playSound(cat); // Output: Meow!

Explanation: In this example, the Animal class has an abstract method makeSound that is overridden by its subclasses Dog and Cat. The playSound function accepts an animal parameter, which can be an instance of any class that extends Animal. The function invokes the makeSound method on the provided animal, without knowing the specific subclass. This demonstrates polymorphism through interface-based programming, where different objects conform to a common interface (in this case, the makeSound method).

Feel free to copy the code and experiment with our javascript compiler

Run