Polymorphism in TypeScript

Introduction to Polymorphism

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 in TypeScript

Polymorphism allows objects to be treated as instances of their parent class or interface rather than their actual class. TypeScript provides polymorphism using class-based inheritance, interfaces, abstract classes, and static typing. Here’s what we’ll cover in this lesson: Understanding Polymorphism : We'll discuss what polymorphism is and why it's a powerful concept in TypeScript programming. Class Inheritance, Interfaces, and Abstract Classes : You'll learn how TypeScript uses classes, inheritance, interfaces, and abstract classes to achieve polymorphism.

Understanding Polymorphism

Polymorphism in TypeScript allows you to call methods on derived objects through a reference to their base class or interface. This approach makes your code more general and maintainable. TypeScript achieves polymorphism primarily through the following mechanisms: Class Inheritance : Classes can extend other classes, allowing derived classes to override methods from their base class. Interfaces : Interfaces define contracts that multiple classes can implement, enabling polymorphic behavior across unrelated classes. Abstract Classes : Abstract classes can define abstract methods that must be implemented by derived classes, providing another way to achieve polymorphism. Real-world analogy: Think of a universal remote control. The remote can control different devices—like a TV, a sound system, or an air conditioner—because each device responds to the same basic commands (like "power on" or "volume up") in its own way. Similarly, polymorphism lets you interact with different objects through a common interface, while each object handles the action in its own specific way. Polymorphism enables a single action to be defined in different ways. The capability to redefine methods across various classes sharing the same interface, abstract class, or base class is a strength of TypeScript OOP.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Class Inheritance, Interfaces, and Abstract Classes

TypeScript uses class inheritance, interfaces, and abstract classes to achieve polymorphism. Here are the rules for achieving polymorphism in TypeScript:

Method Overriding via Class Inheritance: Derived classes can override methods defined in their base classes. This is similar to the concept of method overriding in other object-oriented languages.
Interface Implementation: Multiple classes can implement the same interface, ensuring they provide specific methods. This allows you to write functions that operate on any object implementing the interface.
Abstract Classes: Abstract classes can define abstract methods that must be implemented by subclasses, enabling polymorphism through inheritance.
Static Typing: TypeScript’s static typing ensures that objects conform to the expected structure at compile time, making polymorphic code safer and more predictable.

Example:

TypeScript

interface Animal {
    sound(): void;
}

class Dog implements Animal {
    sound(): void {
        console.log("Dog barks");
    }
}

class Cat implements Animal {
    sound(): void {
        console.log("Cat meows");
    }
}

function playSound(animal: Animal): void {
    animal.sound();
}

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

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

interface Animal {
    sound(): void;
}

class Dog implements Animal {
    sound(): void {
        console.log("Dog barks");
    }
}

class Cat implements Animal {
    sound(): void {
        console.log("Cat meows");
    }
}

function playSound(animal: Animal): void {
    animal.sound();
}

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

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

You can also use polymorphism with arrays of objects:

TypeScript

const animals: Animal[] = [new Dog(), new Cat()];

function playAllSounds(animals: Animal[]): void {
    for (const animal of animals) {
        animal.sound();
    }
}

playAllSounds(animals);
// Output:
// Dog barks
// Cat meows

const animals: Animal[] = [new Dog(), new Cat()];

function playAllSounds(animals: Animal[]): void {
    for (const animal of animals) {
        animal.sound();
    }
}

playAllSounds(animals);
// Output:
// Dog barks
// Cat meows

This demonstrates how a function can operate on an array of different objects (all implementing the Animal interface), calling the appropriate method for each.

Polymorphism in TypeScript

Introduction to Polymorphism