Classes

TypeScript · 6 entries

Access Modifiers

syntax

class Name {
  public prop: Type;
  private prop: Type;
  protected prop: Type;
}

example

class BankAccount {
  public accountHolder: string;
  private balance: number;
  protected accountType: string;

  constructor(holder: string, initial: number) {
    this.accountHolder = holder;
    this.balance = initial;
    this.accountType = "checking";
  }

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

  private validateAmount(amount: number): boolean {
    return amount > 0 && amount <= this.balance;
  }
}

const account = new BankAccount("Alice", 1000);
console.log(account.accountHolder); // OK
// account.balance; // Error: private

output

// public = anywhere, private = same class only, protected = class + subclasses

Note TypeScript access modifiers are compile-time only — at runtime, everything is accessible. For true runtime privacy, use JavaScript's native #private fields (e.g., #balance). The public modifier is the default and can be omitted.

access modifierpublic private protectedclass visibilityencapsulationprivate property

Parameter Properties

syntax

class Name {
  constructor(public prop: Type, private prop2: Type) {}
}

example

// Without parameter properties — verbose
class VerboseUser {
  name: string;
  email: string;
  constructor(name: string, email: string) {
    this.name = name;
    this.email = email;
  }
}

// With parameter properties — concise
class User {
  constructor(
    public readonly name: string,
    public email: string,
    private passwordHash: string
  ) {}

  display(): string {
    return `${this.name} <${this.email}>`;
  }
}

output

// Adding an access modifier to a constructor param auto-declares and assigns the property

Note Parameter properties reduce boilerplate by combining declaration, constructor parameter, and assignment into one. You can combine them with readonly. Regular (unmodified) parameters are not turned into properties — only those prefixed with public, private, protected, or readonly.

parameter propertyconstructor shorthandauto assign constructorshorthand class property

Abstract Classes

syntax

abstract class Name {
  abstract method(): Type;
  concreteMethod(): Type { ... }
}

example

abstract class Shape {
  abstract area(): number;
  abstract perimeter(): number;

  describe(): string {
    return `Area: ${this.area().toFixed(2)}, Perimeter: ${this.perimeter().toFixed(2)}`;
  }
}

class Circle extends Shape {
  constructor(private radius: number) {
    super();
  }

  area(): number {
    return Math.PI * this.radius ** 2;
  }

  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }
}

// const shape = new Shape(); // Error: Cannot instantiate abstract class
const circle = new Circle(5);
console.log(circle.describe());

output

// "Area: 78.54, Perimeter: 31.42"

Note Abstract classes cannot be instantiated directly. They can contain both abstract members (no implementation — subclasses must provide them) and concrete members (shared implementation). Use abstract classes when subclasses share behavior; use interfaces when they only share shape.

abstract classbase classmust implementabstract methodclass template

override Keyword

syntax

class Child extends Parent {
  override method(): Type { ... }
}

example

class Transport {
  getSpeed(): number {
    return 0;
  }

  describe(): string {
    return `Speed: ${this.getSpeed()} km/h`;
  }
}

class Train extends Transport {
  override getSpeed(): number {
    return 300;
  }

  // override getSped(): number { // Error with noImplicitOverride:
  //   return 300;                 // 'getSped' does not exist on base
  // }
}

output

// override keyword verifies the method actually exists on the parent class

Note Enable noImplicitOverride in tsconfig to require the override keyword on all overriding methods. This catches typos (overriding a method that does not exist on the parent) and refactoring bugs (parent method was renamed but child was not updated).

override keywordoverride methodnoImplicitOverrideextend methodsubclass override

Decorators (TC39 / TS 5.0+)

syntax

@decorator
class Name { ... }

class Name {
  @decorator accessor prop = value;
}

example

// TS 5.0+ standard decorators (TC39 Stage 3)
function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

function log(
  target: any,
  context: ClassMethodDecoratorContext
) {
  const methodName = String(context.name);
  return function (this: any, ...args: any[]) {
    console.log(`Calling ${methodName} with`, args);
    return target.call(this, ...args);
  };
}

@sealed
class OrderService {
  @log
  processOrder(orderId: string) {
    console.log(`Processing ${orderId}`);
  }
}

output

// Calling processOrder with ["ord_123"]
// Processing ord_123

Note TS 5.0 introduced TC39 standard decorators — these are different from the legacy experimental decorators. Standard decorators receive a context object instead of the old three-parameter signature. Set "experimentalDecorators": false (or omit it) to use the new standard. Legacy decorators are still available with "experimentalDecorators": true.

decoratorsclass decoratormethod decoratorTC39 decoratorannotation pattern

Classes with satisfies & implements

syntax

class Name implements Interface { ... }

example

interface Serializable {
  serialize(): string;
  deserialize(data: string): void;
}

interface Cacheable {
  cacheKey: string;
  ttlSeconds: number;
}

class UserSession implements Serializable, Cacheable {
  cacheKey: string;
  ttlSeconds = 3600;

  constructor(public userId: string, public token: string) {
    this.cacheKey = `session:${userId}`;
  }

  serialize(): string {
    return JSON.stringify({ userId: this.userId, token: this.token });
  }

  deserialize(data: string): void {
    const parsed = JSON.parse(data);
    this.userId = parsed.userId;
    this.token = parsed.token;
  }
}

output

// A class can implement multiple interfaces, enforcing all their contracts

Note implements is purely a compile-time check — it does not inherit any code. Each property and method must be explicitly defined in the class. If the class already matches the interface shape, implements is optional but serves as documentation and catches regressions.

class implementsmultiple interfacesclass contractserializable patternimplement multiple