Advanced OOP

🏛️ Advanced OOP

🔷 Abstract Classes: Enforce Contracts

An abstract class can't be instantiated. It defines a contract that subclasses must implement:

Copyabstract class Animal {
  abstract makeSound(): void;  // Subclasses MUST implement

  sleep() {
    console.log("Zzz...");  // Concrete method (optional to override)
  }
}

class Dog extends Animal {
  makeSound() {
    console.log("Woof!");  // ✅ Implements abstract method
  }
}

const animal = new Animal();  // ❌ Error: can't instantiate abstract class
const dog = new Dog();         // ✅ OK
dog.makeSound();           // "Woof!"

🔒 Access Modifiers: Control Visibility

TypeScript provides public, private, and protected to control who can access members:

Copyclass BankAccount {
  public accountHolder: string;        // Anyone can read/write
  private balance: number = 0;     // Only this class can access
  protected log: string[] = [];   // This class and subclasses

  constructor(holder: string) {
    this.accountHolder = holder;
  }

  public deposit(amount: number) {
    this.balance += amount;
    this.recordLog(`Deposited ${amount}`);
  }

  private recordLog(message: string) {
    this.log.push(message);
  }

  protected getBalance() {
    return this.balance;  // Only subclasses can call
  }
}

const account = new BankAccount("Alice");
account.deposit(100);              // ✅ public
console.log(account.accountHolder);  // ✅ public
// account.balance;           // ❌ private — error
// account.recordLog("...");  // ❌ private — error

Copypublic prop: string;
// Accessible everywhere

Copyprivate prop: string;
// Only inside this class

Copyprotected prop: string;
// This class + subclasses

Copyreadonly prop: string;
// Can't reassign after init

📌 Static Members: Class-Level Data

Static members belong to the class itself, not instances:

Copyclass Counter {
  static count: number = 0;

  static reset() {
    Counter.count = 0;
  }

  constructor() {
    Counter.count++;  // Increment class-level counter
  }
}

const c1 = new Counter();
const c2 = new Counter();

console.log(Counter.count);  // 2 — shared across all instances
Counter.reset();
console.log(Counter.count);  // 0

🎯 Getters & Setters: Computed Properties

Getters and setters let you use properties while running custom logic:

Copyclass User {
  private _age: number = 0;

  get age(): number {
    return this._age;
  }

  set age(value: number) {
    if (value < 0) {
      throw new Error("Age can't be negative");
    }
    this._age = value;
  }
}

const user = new User();
user.age = 25;          // ✅ Calls setter with validation
console.log(user.age);  // ✅ Calls getter
user.age = -5;          // ❌ Error: Age can't be negative

Why use getters/setters?

• Validation: Check constraints before setting
• Computed values: Calculate on-the-fly
• Side effects: Log, notify, update cache
• Clean API: Property syntax instead of methods

🏗️ Real-World Pattern: Sealed Class with Private State

Copyabstract class BaseConfig {
  abstract validate(): boolean;
}

class AppConfig extends BaseConfig {
  private _port: number;
  private _host: string;
  readonly version: string;
  static instance: AppConfig;

  private constructor(port: number, host: string) {
    super();
    this._port = port;
    this._host = host;
    this.version = "1.0.0";
  }

  static create(port: number, host: string): AppConfig {
    if (!AppConfig.instance) {
      AppConfig.instance = new AppConfig(port, host);
    }
    return AppConfig.instance;
  }

  get port(): number {
    return this._port;
  }

  set port(value: number) {
    if (value < 1 || value > 65535) {
      throw new Error("Invalid port");
    }
    this._port = value;
  }

  validate(): boolean {
    return this._port > 0 && this._host.length > 0;
  }
}

// Usage: factory pattern with singleton
const config = AppConfig.create(3000, "localhost");
console.log(config.port);  // 3000

💻 Coding Challenges

🎯 What's Next

With advanced OOP patterns mastered, we'll explore Type Utilities & Inference — leveraging TypeScript's powerful type system to build reusable, composable type utilities.