Summary
This chapter covers how to define and use abstract classes with abstract methods in TypeScript to enforce that subclasses implement required behaviors.

General domain of usage
Geometric shape modeling and computations.

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?

Deepen your understanding of object-oriented programming with TypeScript by working with classes, encapsulation, interfaces, generics, and inheritance. Learn how to structure reusable components, enforce contracts, and design scalable class hierarchies.

Build a strong foundation in TypeScript classes by defining properties, methods, constructors, and static members. Learn how class structure improves clarity, reusability, and code organization.

Control visibility and encapsulation using public, private, and protected members. Apply these modifiers to create safer, more predictable class designs that hide implementation details and expose only what is needed.

Use abstract classes and interfaces to enforce structure and define contracts between components. Explore how these tools support scalable architecture and help manage complex object relationships.

Write flexible, type-safe classes by applying generics to class definitions and methods. Create reusable patterns that adapt to multiple data types while maintaining strong typing.

Build class hierarchies with inheritance and leverage polymorphism to create extendable systems. Learn how method overriding, super calls, and shared behavior support clean and maintainable object-oriented design.

Implementing Abstract Classes

Awesome!

Implementing Abstract Classes