Classes & Object-Oriented TypeScript

🏗️ Classes & Object-Oriented TypeScript

🏛️ Basic Class Structure

Your First Class

Copyclass Dog {
  name: string;
  age: number;

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

  bark(): void {
    console.log(`${this.name} says woof!`);
  }
}

// Create an instance
const myDog = new Dog("Buddy", 3);
myDog.bark();  // Output: Buddy says woof!

🔐 Access Modifiers

Copyclass User {
  public name: string;
}
const user = new User();
user.name = "Alice";  // ✅ OK

Copyclass User {
  private password: string;
}
const user = new User();
console.log(user.password);  // ❌ Error!

Copyclass Animal {
  protected health: number;
}
class Dog extends Animal {
  heal() { this.health++; }  // ✅ OK
}

Copyclass User {
  readonly id: number;
  constructor(id: number) {
    this.id = id;  // ✅ OK in constructor
  }
}
const user = new User(1);
user.id = 2;  // ❌ Error! readonly

Why Access Modifiers Matter

Consider a bank account:

Copyclass BankAccount {
  private balance: number = 0;

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

  withdraw(amount: number): boolean {
    if (amount <= this.balance) {
      this.balance -= amount;
      return true;
    }
    return false;
  }

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

const account = new BankAccount();
account.deposit(100);  // ✅ OK - uses method
console.log(account.getBalance());  // ✅ OK - public method
account.balance = 1000000;  // ❌ Error! balance is private

👨‍👩‍👧‍👦 Inheritance

Copyclass Animal {
  name: string;

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

  move(): void {
    console.log(`${this.name} is moving`);
  }
}

class Dog extends Animal {
  bark(): void {
    console.log(`${this.name} says woof!`);
  }

  // Override the parent method
  move(): void {
    console.log(`${this.name} runs fast`);
  }
}

const dog = new Dog("Buddy");
dog.move();  // Output: Buddy runs fast (overridden method)
dog.bark();  // Output: Buddy says woof!

super: Calling Parent Methods

Use super to call parent class methods:

Copyclass Dog extends Animal {
  breed: string;

  constructor(name: string, breed: string) {
    super(name);  // Call parent constructor
    this.breed = breed;
  }

  move(): void {
    super.move();  // Call parent method
    console.log(` (as a ${this.breed})`);
  }
}

🎭 Abstract Classes

Copyabstract class Shape {
  abstract getArea(): number;  // Subclasses MUST implement

  public describe(): void {
    console.log(`This shape has area: ${this.getArea()}`);
  }
}

// ❌ Can't do this:
const shape = new Shape();  // Error! Can't instantiate abstract class

class Circle extends Shape {
  radius: number;

  constructor(radius: number) {
    super();
    this.radius = radius;
  }

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

// ✅ This works:
const circle = new Circle(5);
circle.describe();  // Output: This shape has area: 78.539...

⚡ Constructor Parameter Shorthand

TypeScript lets you declare and initialize properties directly in the constructor:

Copy// Before (verbose):
class User {
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

// After (shorthand):
class User {
  constructor(
    public name: string,
    public age: number
  ) {}
}

// Both are equivalent!

💻 Coding Challenges

🎯 What's Next

Classes are powerful, but sometimes you need more flexibility. Chapter 6 introduces Generics — the TypeScript way to write code that works with many types while staying type-safe.