Object-Oriented Programming Principles

OOP is built on four fundamental pillars that guide software design.

1. Encapsulation

// Bad: Exposing internal state
class BankAccountBad {
  public balance: number = 0;
}

// Good: Encapsulating state with controlled access
class BankAccount {
  private balance: number = 0;

  deposit(amount: number): void {
    if (amount <= 0) throw new Error('Deposit must be positive');
    this.balance += amount;
  }

  withdraw(amount: number): void {
    if (amount > this.balance) throw new Error('Insufficient funds');
    this.balance -= amount;
  }

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

2. Abstraction

// Abstract interface hides implementation details
interface PaymentProcessor {
  processPayment(amount: number, currency: string): Promise;
}

class StripeProcessor implements PaymentProcessor {
  async processPayment(amount: number, currency: string): Promise {
    // Stripe-specific implementation hidden
    return { transactionId: 'stripe_123', status: 'success' };
  }
}

class PayPalProcessor implements PaymentProcessor {
  async processPayment(amount: number, currency: string): Promise {
    // PayPal-specific implementation hidden
    return { transactionId: 'pp_456', status: 'success' };
  }
}

3. Inheritance

abstract class Vehicle {
  protected speed: number = 0;

  constructor(protected brand: string) {}

  abstract start(): void;

  accelerate(amount: number): void {
    this.speed += amount;
  }
}

class Car extends Vehicle {
  start(): void {
    console.log(`Starting ${this.brand} car...`);
  }
}

class Motorcycle extends Vehicle {
  start(): void {
    console.log(`Kick-starting ${this.brand}...`);
  }
}

4. Polymorphism

interface Shape {
  area(): number;
}

class Rectangle implements Shape {
  constructor(private width: number, private height: number) {}
  area(): number { return this.width * this.height; }
}

class Circle implements Shape {
  constructor(private radius: number) {}
  area(): number { return Math.PI * this.radius ** 2; }
}

// Polymorphic usage
function calculateTotalArea(shapes: Shape[]): number {
  return shapes.reduce((total, shape) => total + shape.area(), 0);
}

const shapes: Shape[] = [new Rectangle(10, 5), new Circle(7)];
console.log(calculateTotalArea(shapes)); // Works with any Shape

Four Pillars of OOP

Four Pillars of OOP

Object-Oriented Programming Principles

1. Encapsulation

2. Abstraction

3. Inheritance

4. Polymorphism