Summary  
This chapter explains how to use abstract classes to define methods without implementation as a contract that all subclasses must implement, ensuring consistent APIs and preventing incomplete implementations.  

General domain of usage  
Geometric modeling (e.g., calculating shapes’ area and perimeter)

abstract class Shape {
  abstract getArea(): number;
  abstract getPerimeter(): number;
}

class Rectangle extends Shape {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }

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

  getPerimeter(): number {
    return 2 * (this.width + this.height);
  }
}

const rect = new Rectangle(10, 5);
console.log(rect.getArea());      // 50
console.log(rect.getPerimeter()); // 30

When you use an **abstract class** in TypeScript, you define methods that have no implementation, called **abstract methods**. These methods act as a contract: any subclass that extends the abstract class must provide concrete implementations for all abstract methods. This ensures that every subclass fulfills the required behaviors specified by the abstract class, helping you enforce consistent APIs and reducing errors from missing functionality. If a subclass does not implement all abstract methods, TypeScript will report a compilation error, preventing incomplete implementations.

What must a subclass do when it extends an abstract class with abstract methods?

Learn how TypeScript leverages object-oriented programming concepts to create structured, reusable, and type-safe code. Explore classes, properties, methods, access modifiers, encapsulation, inheritance, polymorphism, interfaces, and generics with practical examples.

Implementing Abstract Classes