TypeScript Classes & Access Modifiers — Complete Interview Guide

Access Modifiers Overview

class BankAccount {
  public  owner: string;       // Accessible from anywhere (default)
  protected balance: number;   // Accessible in this class and subclasses
  private  pin: string;        // Accessible only in this class
  readonly accountId: string;  // Can be set once (in constructor), then immutable

  constructor(owner: string, pin: string) {
    this.owner = owner;
    this.pin = pin;
    this.balance = 0;
    this.accountId = crypto.randomUUID();
  }

  public getBalance(): number {
    return this.balance; // Can access private/protected inside the class
  }

  private validatePin(input: string): boolean {
    return input === this.pin; // Only this class can call validatePin
  }
}

const account = new BankAccount("Alice", "1234");
account.owner;          // OK — public
account.balance;        // Error — protected
account.pin;            // Error — private
account.accountId;      // OK — readonly, but readable
account.accountId = "x"; // Error — readonly

Parameter Properties — Shorthand Constructor

TypeScript's parameter properties declare and initialise class properties directly from constructor parameters — eliminating boilerplate:

// Verbose — the traditional way
class User {
  public name: string;
  private email: string;
  protected role: string;

  constructor(name: string, email: string, role: string) {
    this.name = name;
    this.email = email;
    this.role = role;
  }
}

// Concise — parameter properties (access modifier in constructor signature)
class User {
  constructor(
    public  name: string,
    private email: string,
    protected role: string,
    readonly id: number = Math.random()
  ) {}
  // name, email, role, id are automatically declared AND initialised
}

TypeScript private vs JavaScript # (Hard Private)

TypeScript's private is a compile-time-only check — at runtime the property is still publicly accessible on the object. JavaScript's # syntax creates a true runtime private field that cannot be accessed even via reflection:

class TokenService {
  private tsPrivate = "secret";    // TypeScript only — erased at runtime
  #jsPrivate = "also-secret";      // JavaScript private field — runtime enforced

  getTokenTs() { return this.tsPrivate; }
  getTokenJs() { return this.#jsPrivate; }
}

const svc = new TokenService();
(svc as any).tsPrivate; // Works at runtime — TypeScript private is compile-time only!
(svc as any)["#jsPrivate"]; // undefined — hard private, inaccessible even with any
svc.#jsPrivate; // Error at compile time AND runtime

For truly sensitive data (tokens, keys, passwords in memory), prefer # hard private fields. Use TypeScript private for API encapsulation enforced by the type system.

Abstract Classes

Abstract classes define a template — they can contain implemented methods AND abstract methods that subclasses must implement. They cannot be instantiated directly:

abstract class Repository<T> {
  // Concrete method — shared implementation available to all subclasses
  async findOrFail(id: string): Promise<T> {
    const entity = await this.findById(id);
    if (!entity) throw new Error(`Not found: ${id}`);
    return entity;
  }

  // Abstract methods — subclasses MUST implement these
  abstract findById(id: string): Promise<T | null>;
  abstract save(entity: T): Promise<void>;
  abstract delete(id: string): Promise<void>;
}

class UserRepository extends Repository<User> {
  async findById(id: string): Promise<User | null> {
    return db.users.findOne({ id });
  }
  async save(user: User): Promise<void> {
    await db.users.upsert(user);
  }
  async delete(id: string): Promise<void> {
    await db.users.delete({ id });
  }
}

new Repository(); // Error — cannot instantiate abstract class
new UserRepository(); // OK

Static Members

class Config {
  private static instance: Config | null = null;
  private settings: Record<string, string> = {};

  // Singleton pattern — static factory method
  static getInstance(): Config {
    if (!Config.instance) {
      Config.instance = new Config();
    }
    return Config.instance;
  }

  // Static utility method — no instance needed
  static fromEnv(): Config {
    const cfg = new Config();
    cfg.settings = { ...process.env } as Record<string, string>;
    return cfg;
  }
}

const cfg = Config.getInstance(); // Access via class, not instance

TypeScript Structural Typing and Access Modifiers

TypeScript uses structural typing — two types are compatible if their shapes match. But access modifiers affect structural compatibility in a subtle way:

class A { private secret = 1; public value = 2; }
class B { private secret = 1; public value = 2; }

// Despite looking identical, A and B are NOT structurally compatible
// because their private fields are declared in different classes
const a: A = new B(); // Error — A's private 'secret' is not from B

class C extends A {} // OK — C inherits A's private 'secret'
const c: A = new C(); // OK — C is structurally compatible with A