Why Class implementing multiple interfaces in Typescript? - Purpose & Use Cases

The Big Idea

What if you could give one class many clear jobs without mixing things up?

The Scenario

Imagine you have a robot that needs to do many jobs: it can clean, cook, and also entertain guests. If you try to write separate instructions for each job manually every time you build a new robot, it becomes confusing and hard to keep track.

The Problem

Writing all the instructions for each robot from scratch is slow and easy to mess up. You might forget some steps or mix up the order. It's like trying to remember every detail without a checklist, which leads to mistakes and wasted time.

The Solution

Using a class that implements multiple interfaces is like giving the robot a clear set of checklists for each job it can do. The class promises to follow all these checklists, so you know exactly what the robot can do and how. This keeps things organized and easy to manage.

Before vs After

✗ Before

class Robot {
  clean() { /* cleaning code */ }
  cook() { /* cooking code */ }
  entertain() { /* entertaining code */ }
}

✓ After

interface Cleaner { clean(): void; }
interface Cook { cook(): void; }
interface Entertainer { entertain(): void; }

class Robot implements Cleaner, Cook, Entertainer {
  clean() { /* cleaning code */ }
  cook() { /* cooking code */ }
  entertain() { /* entertaining code */ }
}

What It Enables

This lets you build clear, organized programs where one class can promise to do many different jobs, making your code easier to understand and reuse.

Real Life Example

Think of a smartphone app that can send messages, play music, and track fitness. Each feature is like an interface, and the app class implements all of them to work smoothly together.

Key Takeaways

Manual coding for multiple roles is confusing and error-prone.

Implementing multiple interfaces organizes responsibilities clearly.

It makes your code easier to read, maintain, and expand.