Classes, access modifiers and abstract

A TypeScript class is a JavaScript class with types and a few extra keywords. The one shorthand worth knowing is the parameter property: a modifier on a constructor parameter declares the field and assigns it.

class Invoice {
  constructor(
    public readonly id: string,     // declared and assigned in one go
    private total: number,
  ) {}
}

The modifiers

• public — the default; usable anywhere.
• protected — usable inside the class and its subclasses.
• private — usable only inside the class that declares it.
• readonly — assignable only in the declaration or the constructor.

All four are compile-time checks. They are erased with the rest of the types, so the field is an ordinary property at runtime.

private against #private

JavaScript has its own private fields, written #name. Those are enforced by the runtime: the property does not exist from the outside at all, so serialisation, Object.keys and a cast cannot reach it.

1class Account {2  private balance = 0;    // TypeScript-only privacy3  #pin: string;           // JavaScript private field: enforced at runtime4 5  constructor(readonly owner: string, pin: string) {6    this.#pin = pin;7  }8 9  deposit(amount: number): void {10    this.balance += amount;11  }12 13  checkPin(guess: string): boolean {14    return guess === this.#pin;15  }16}17 18export function run(): unknown[] {19  const acct = new Account("Nino", "4321");20  acct.deposit(50);21  return [22    JSON.stringify(acct),                 // what a log line or an API response sees23    (acct as any).balance,                // "private" is one cast away24    (acct as any).pin ?? "no such key",   // #pin is not a property at all25    acct.checkPin("4321"),26  ];27}

balance is "private" to the compiler and plainly visible to JSON.stringify and to anyone who writes as any. #pin is not visible to either. Use # when the value must not leak (a secret, a token); use private when the aim is only to keep other code from depending on an implementation detail.

Abstract classes

An abstract class cannot be instantiated by name, and may declare abstract members with no body that every concrete subclass must implement. The useful pattern is a concrete method in the base class that fixes the order of the steps and calls abstract ones — the subclasses fill in the steps, never the order:

1abstract class Report {2  constructor(protected readonly title: string) {}3 4  // Each subclass says how; the base class owns the order of the steps.5  protected abstract body(): string;6 7  render(): string {8    return `# ${this.title}\n${this.body()}`;9  }10}11 12class SalesReport extends Report {13  constructor(private readonly total: number) {14    super("Sales");15  }16  protected body(): string {17    return `total: ${this.total}`;18  }19}20 21export function run(): string[] {22  const out = [new SalesReport(1200).render()];23  // abstract is erased too: at runtime Report is an ordinary class.24  try {25    const bare = new (Report as any)("Bare");26    out.push(bare.render());27  } catch (e) {28    out.push(String(e));29  }30  return out;31}

abstract is erased as well. With a cast, Report itself can be constructed at runtime, and the missing step fails only when it is called.

implements or extends

class Cache implements Store only checks that the class has the shape of Store; it inherits nothing. extends inherits code. Prefer an interface plus implements for a contract, and an abstract base class only when there is shared behaviour worth inheriting.

Common mistakes

• Treating private as security. It hides nothing at runtime; the example's balance is in the JSON. Use #field for data that must not escape.
• Calling an overridable method from a constructor. The base constructor runs before the subclass's own fields are initialised, so a subclass method called from there sees them undefined (the example after this list).
• Using abstract where an interface is enough. If the base class has no shared code, an interface keeps the hierarchy flat.
• Expecting readonly fields to be frozen. Like every modifier, it is checked by the compiler only.

The constructor-order mistake, run:

1abstract class Widget {2  readonly label: string;3 4  constructor() {5    // Runs before Button's own fields have been initialised.6    this.label = this.describe();7  }8 9  protected abstract describe(): string;10}11 12class Button extends Widget {13  private readonly text = "Save";14 15  protected describe(): string {16    return `button: ${this.text}`;17  }18}19 20export function run(): string[] {21  const b = new Button();22  return [b.label, (b as any).describe()];23}

What interviewers ask

• What is the difference between private and #private? private is a compile-time check on an ordinary property; #private is a JavaScript private field that the runtime itself keeps hidden.
• Abstract class or interface? An interface is a pure contract, erased completely; an abstract class can carry shared implementation and constructor logic, and exists at runtime.
• What is protected for? Members that subclasses need but outside callers should not touch — typically the steps of a template method.