Implementing Interfaces

A class can implement MULTIPLE interfaces — it must satisfy ALL of them. This is where TypeScript's contract system truly shines. The syntax uses commas: class X implements A, B, C { ... }. Every method and property from every interface must be present in the class, or TypeScript will flag the errors immediately.

interface Serializable {
  serialize(): string;
}

interface Loggable {
  log(): void;
}

class SmartDevice
  implements Serializable, Loggable {
  serialize() {
    return JSON.stringify(this);
  }
  log() {
    console.log("Device logged");
  }
}

const phone = new SmartDevice();
phone.serialize(); // "{}"
phone.log(); // "Device logged"

If you miss even ONE method from any interface, TypeScript catches it. Every method from every interface is mandatory — no partial implementations allowed. This is like the Nizam demanding that every royal building must satisfy BOTH the fire safety decree AND the architectural beauty decree — you can't satisfy one and ignore the other. Both must be honored, or the inspector rejects your building.

A powerful real-world pattern is implementing a generic interface. This is heavily used in repository patterns, data layers, and service classes across production codebases:

interface Repository<T> {
  findById(id: string): T;
  save(item: T): void;
  delete(id: string): void;
}

interface User {
  id: string;
  name: string;
}

class UserRepository
  implements Repository<User> {
  private items: User[] = [];

  findById(id: string): User {
    return this.items.find(
      u => u.id === id
    )!;
  }

  save(item: User): void {
    this.items.push(item);
  }

  delete(id: string): void {
    this.items = this.items.filter(
      u => u.id !== id
    );
  }
}

Now UserRepository must provide all three methods with the exact signatures. If you implement Repository<Product> instead, the types change accordingly. The interface stays the same, but the implementation adapts — like using the same blueprint for different palaces across the kingdom, each with its own unique purpose but following the same royal standards.

There's also an advanced pattern where interfaces describe constructor signatures using the new keyword:

interface Constructable {
  new (name: string): any;
}

// Used in factory patterns
function createInstance(
  Ctor: Constructable,
  name: string
) {
  return new Ctor(name);
}

This is mainly used in factories and dependency injection — advanced patterns where you need to pass classes around as values. The new signature ensures the class can be instantiated with specific parameters. You won't use this daily, but knowing it helps when you encounter it in frameworks like Angular or NestJS, where dependency injection relies heavily on such patterns to wire things together automatically.