Classes & OOP

Introduction

JavaScript classes already exist; TypeScript layers access control, parameter shorthand, abstract classes, and interface enforcement on top of them, making object-oriented code far more self-documenting and safe to refactor.

Class Basics

A class declares typed fields, a constructor to initialize them, and methods that operate on the instance. TypeScript checks that every field is assigned a value of the correct type.

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): string {
    return `Hi, I'm ${this.name}`;
  }
}

const p = new Person("Amol", 29);
console.log(p.greet());

Access Modifiers

TypeScript adds `public` (the default — accessible from anywhere), `private` (accessible only inside the declaring class), and `protected` (accessible inside the declaring class and its subclasses). These are checked only by the compiler; the compiled JavaScript output still contains a normal, accessible property. For genuine runtime privacy, JavaScript's own `#fieldName` syntax should be used instead.

class BankAccount {
  private balance: number = 0;

  deposit(amount: number): void {
    this.balance += amount;
  }

  getBalance(): number {
    return this.balance;
  }
}

Parameter Properties

Adding an access modifier directly in front of a constructor parameter is shorthand that both declares the field and assigns it — no need to repeat the field declaration and the `this.x = x` assignment separately.

class Product {
  constructor(
    public readonly id: number,
    private price: number
  ) {}

  getPrice(): number {
    return this.price;
  }
}

Inheritance

A class can extend a base class with `extends`, inheriting its fields and methods and optionally overriding them. Inside a subclass constructor, `super(...)` must be called before `this` can be used, to run the base class's own constructor first.

class Animal {
  constructor(protected name: string) {}

  speak(): string {
    return `${this.name} makes a sound.`;
  }
}

class Dog extends Animal {
  speak(): string {
    return `${this.name} barks.`;
  }
}

console.log(new Dog("Rex").speak());

Abstract Classes

An `abstract class` cannot be instantiated directly — it exists only to be extended. It can mix concrete methods (with a real implementation) with `abstract` methods (a signature every subclass must implement).

abstract class Shape {
  abstract area(): number;

  describe(): string {
    return `Area: ${this.area()}`;
  }
}

class Square extends Shape {
  constructor(private side: number) {
    super();
  }
  area(): number {
    return this.side ** 2;
  }
}

Implementing Interfaces

A class can implement one or more interfaces with `implements`, and TypeScript verifies every required property and method is actually present. Unlike `extends` (single inheritance from one base class), a class may implement any number of interfaces at once.

interface Printable {
  print(): void;
}

class Invoice implements Printable {
  print(): void {
    console.log("Printing invoice...");
  }
}

Getters and Setters

`get` and `set` accessors let a class expose computed or validated properties that look like plain fields from the outside, while running real code behind the scenes on every read or write.

class Temperature {
  private _celsius = 0;

  get fahrenheit(): number {
    return this._celsius * 9 / 5 + 32;
  }

  set fahrenheit(value: number) {
    this._celsius = (value - 32) * 5 / 9;
  }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You can now build well-structured, type-safe object-oriented code with TypeScript classes. Next, you'll learn generics — the tool that lets you write reusable functions and classes that stay fully type-safe across many different types.