🔄 Method Overriding: Customizing Inherited Behavior

🎯 Introduction

Welcome to the powerful world of method overriding! 🎉 In this guide, we’ll explore how to customize and enhance inherited behavior by replacing parent class methods with your own implementations.

You’ll discover how method overriding is like redecorating a room 🏠 - you keep the structure but change how things work inside. Whether you’re building game characters with unique abilities 🎮 or payment systems with different processing methods 💳, understanding method overriding is essential for flexible, maintainable code.

By the end of this tutorial, you’ll feel confident customizing any inherited behavior! Let’s dive in! 🏊‍♂️

📚 Understanding Method Overriding

🤔 What is Method Overriding?

Method overriding is like giving a child class the ability to say “I’ll do this my own way!” 🙋‍♂️ Think of it as customizing a recipe - you keep the recipe name but change the ingredients and steps.

In TypeScript terms, method overriding allows a child class to provide a specific implementation of a method that’s already defined in its parent class. This means you can:

✨ Customize behavior for specific types
🚀 Implement specialized functionality
🛡️ Maintain consistent interfaces
🔧 Create polymorphic behavior

💡 Why Use Method Overriding?

Here’s why developers love method overriding:

Customization 🎨: Each subclass can behave differently
Polymorphism 🎭: Same method name, different behaviors
Flexibility 🤸‍♂️: Change behavior without changing interface
Specialization 🎯: Fine-tune functionality for specific cases

Real-world example: Imagine a drawing application 🎨. Your base Shape class has a draw() method, but Circle, Rectangle, and Triangle each override it to draw themselves differently.

🔧 Basic Syntax and Usage

📝 Simple Example

Let’s start with a friendly example:

// 🎵 Base music player
class MusicPlayer {
  currentSong: string = '';
  volume: number = 50;

  // 🎵 Basic play method
  play(song: string): void {
    this.currentSong = song;
    console.log(`🎵 Playing: "${song}" at volume ${this.volume}`);
  }

  // ⏹️ Basic stop method
  stop(): void {
    console.log(`⏹️ Stopped playing: "${this.currentSong}"`);
    this.currentSong = '';
  }

  // 🔊 Volume control
  setVolume(volume: number): void {
    this.volume = Math.max(0, Math.min(100, volume));
    console.log(`🔊 Volume set to: ${this.volume}`);
  }

  // 📊 Player status
  getStatus(): string {
    return this.currentSong 
      ? `▶️ Playing: "${this.currentSong}" | 🔊 ${this.volume}%`
      : '⏹️ Stopped';
  }
}

// 🎧 Premium player with enhanced features
class PremiumMusicPlayer extends MusicPlayer {
  private equalizer: string = 'flat';
  private playlistMode: boolean = false;

  // 🔄 Override play method with premium features
  play(song: string): void {
    // 🎵 Custom premium play logic
    this.currentSong = song;
    console.log(`🎧 Premium Playing: "${song}"`);
    console.log(`🎛️ Equalizer: ${this.equalizer} | 🔊 Volume: ${this.volume}`);
    
    if (this.playlistMode) {
      console.log('📋 Playlist mode active - next song queued');
    }
  }

  // 🔄 Override stop method with premium features
  stop(): void {
    if (this.currentSong) {
      console.log(`⏸️ Premium Stop: Saving position for "${this.currentSong}"`);
      console.log('💾 Progress saved for resume later');
    }
    
    this.currentSong = '';
    console.log('⏹️ Premium player stopped');
  }

  // 🎛️ Premium-specific method
  setEqualizer(preset: string): void {
    this.equalizer = preset;
    console.log(`🎛️ Equalizer set to: ${preset}`);
  }

  // 📋 Toggle playlist mode
  togglePlaylistMode(): void {
    this.playlistMode = !this.playlistMode;
    console.log(`📋 Playlist mode: ${this.playlistMode ? 'ON' : 'OFF'}`);
  }

  // 🔄 Override status with premium info
  getStatus(): string {
    const baseStatus = this.currentSong 
      ? `▶️ Premium Playing: "${this.currentSong}"`
      : '⏹️ Premium Stopped';
    
    return `${baseStatus} | 🎛️ ${this.equalizer} | 📋 ${this.playlistMode ? 'Playlist' : 'Single'} | 🔊 ${this.volume}%`;
  }
}

// 🎮 Let's test the overriding!
const basicPlayer = new MusicPlayer();
const premiumPlayer = new PremiumMusicPlayer();

console.log('=== Basic Player ===');
basicPlayer.play('TypeScript Blues');
console.log(basicPlayer.getStatus());
basicPlayer.stop();

console.log('\n=== Premium Player ===');
premiumPlayer.setEqualizer('rock');
premiumPlayer.togglePlaylistMode();
premiumPlayer.play('Advanced TypeScript Symphony'); // Different behavior!
console.log(premiumPlayer.getStatus());
premiumPlayer.stop(); // Different behavior!

💡 Explanation: Notice how the PremiumMusicPlayer overrides play(), stop(), and getStatus() methods to provide enhanced functionality while keeping the same method signatures!

🎯 Overriding with Super Calls

Sometimes you want to enhance rather than completely replace parent behavior:

// 🏪 Base online store
class OnlineStore {
  items: Map<string, number> = new Map(); // item -> price
  discountRate: number = 0;

  // 🛒 Add item to store
  addItem(name: string, price: number): void {
    this.items.set(name, price);
    console.log(`➕ Added "${name}" for $${price}`);
  }

  // 💰 Calculate total price
  calculateTotal(itemsToBuy: string[]): number {
    let total = 0;
    
    for (const item of itemsToBuy) {
      const price = this.items.get(item);
      if (price) {
        total += price;
      } else {
        console.log(`❌ Item "${item}" not found`);
      }
    }

    const discount = total * this.discountRate;
    const finalTotal = total - discount;
    
    console.log(`💰 Subtotal: $${total.toFixed(2)}`);
    if (discount > 0) {
      console.log(`🎊 Discount: -$${discount.toFixed(2)}`);
    }
    console.log(`💳 Total: $${finalTotal.toFixed(2)}`);
    
    return finalTotal;
  }

  // 🎯 Apply discount
  setDiscount(rate: number): void {
    this.discountRate = Math.max(0, Math.min(1, rate));
    console.log(`🎊 Discount rate set to: ${(this.discountRate * 100).toFixed(1)}%`);
  }
}

// 💎 Premium store with loyalty rewards
class PremiumStore extends OnlineStore {
  loyaltyPoints: number = 0;
  membershipLevel: 'bronze' | 'silver' | 'gold' = 'bronze';

  // 🔄 Override addItem to include loyalty points
  addItem(name: string, price: number): void {
    // 📞 Do the basic item addition
    super.addItem(name, price);
    
    // ✨ Add premium features
    const pointsEarned = Math.floor(price / 10); // 1 point per $10
    this.loyaltyPoints += pointsEarned;
    console.log(`⭐ Earned ${pointsEarned} loyalty points! Total: ${this.loyaltyPoints}`);
  }

  // 🔄 Override calculateTotal with membership benefits
  calculateTotal(itemsToBy: string[]): number {
    // 🏆 Apply membership discount first
    const membershipDiscounts = {
      bronze: 0.05,  // 5%
      silver: 0.10,  // 10%
      gold: 0.15     // 15%
    };

    const originalDiscount = this.discountRate;
    const membershipDiscount = membershipDiscounts[this.membershipLevel];
    
    // 🎯 Combine discounts (don't stack multiplicatively)
    const totalDiscount = Math.min(0.5, originalDiscount + membershipDiscount);
    this.discountRate = totalDiscount;

    console.log(`👑 Membership level: ${this.membershipLevel.toUpperCase()}`);
    console.log(`🎊 Total discount rate: ${(totalDiscount * 100).toFixed(1)}%`);

    // 📞 Calculate with enhanced discount
    const total = super.calculateTotal(itemsToBy);

    // ✨ Award loyalty points for purchase
    const pointsEarned = Math.floor(total / 5); // 1 point per $5 spent
    this.loyaltyPoints += pointsEarned;
    console.log(`⭐ Purchase bonus: +${pointsEarned} loyalty points! Total: ${this.loyaltyPoints}`);

    // 🔄 Restore original discount for next calculation
    this.discountRate = originalDiscount;

    return total;
  }

  // 💎 Upgrade membership based on loyalty points
  checkMembershipUpgrade(): void {
    let newLevel: 'bronze' | 'silver' | 'gold' = 'bronze';
    
    if (this.loyaltyPoints >= 1000) {
      newLevel = 'gold';
    } else if (this.loyaltyPoints >= 500) {
      newLevel = 'silver';
    }

    if (newLevel !== this.membershipLevel) {
      this.membershipLevel = newLevel;
      console.log(`🎉 Congratulations! Upgraded to ${newLevel.toUpperCase()} membership!`);
    }
  }

  // 🎁 Redeem loyalty points
  redeemPoints(points: number): void {
    if (points <= this.loyaltyPoints && points >= 100) {
      this.loyaltyPoints -= points;
      const value = points / 10; // $1 per 10 points
      console.log(`🎁 Redeemed ${points} points for $${value} credit!`);
    } else {
      console.log('❌ Invalid redemption amount');
    }
  }
}

// 🛒 Let's go shopping!
const premiumStore = new PremiumStore();

// Add some items
premiumStore.addItem('TypeScript Hoodie', 45);
premiumStore.addItem('Programming Mug', 15);
premiumStore.addItem('Mechanical Keyboard', 120);

// Make a purchase
const cart = ['TypeScript Hoodie', 'Programming Mug'];
premiumStore.calculateTotal(cart);

// Check for upgrades
premiumStore.checkMembershipUpgrade();

💡 Practical Examples

🎮 Example 1: RPG Character Combat System

Let’s create a combat system where different character types have unique fighting styles:

// ⚔️ Base combat character
class CombatCharacter {
  name: string;
  health: number;
  maxHealth: number;
  damage: number;
  defense: number;

  constructor(name: string, health: number, damage: number, defense: number) {
    this.name = name;
    this.health = health;
    this.maxHealth = health;
    this.damage = damage;
    this.defense = defense;
  }

  // ⚔️ Basic attack method - to be overridden
  attack(target: CombatCharacter): void {
    const actualDamage = Math.max(1, this.damage - target.defense);
    target.takeDamage(actualDamage);
    console.log(`⚔️ ${this.name} attacks ${target.name} for ${actualDamage} damage!`);
  }

  // 🛡️ Take damage
  takeDamage(damage: number): void {
    this.health = Math.max(0, this.health - damage);
    console.log(`💥 ${this.name} takes ${damage} damage! Health: ${this.health}/${this.maxHealth}`);
    
    if (this.health === 0) {
      console.log(`💀 ${this.name} has been defeated!`);
    }
  }

  // 💖 Heal
  heal(amount: number): void {
    const oldHealth = this.health;
    this.health = Math.min(this.maxHealth, this.health + amount);
    const actualHeal = this.health - oldHealth;
    console.log(`💖 ${this.name} heals for ${actualHeal} HP! Health: ${this.health}/${this.maxHealth}`);
  }

  // 📊 Character status
  getStatus(): string {
    const healthPercent = Math.round((this.health / this.maxHealth) * 100);
    return `${this.name}: ${this.health}/${this.maxHealth} HP (${healthPercent}%)`;
  }

  // 💀 Check if defeated
  isDefeated(): boolean {
    return this.health <= 0;
  }
}

// 🧙‍♂️ Wizard with magical attacks
class Wizard extends CombatCharacter {
  mana: number;
  maxMana: number;
  spellPower: number;

  constructor(name: string) {
    super(name, 80, 25, 5); // Lower HP, higher damage, low defense
    this.mana = 100;
    this.maxMana = 100;
    this.spellPower = 30;
  }

  // 🔄 Override attack with magical spells
  attack(target: CombatCharacter): void {
    if (this.mana < 20) {
      // 📖 Mana too low, use basic staff hit
      console.log(`🪄 ${this.name} is out of mana! Using staff attack...`);
      super.attack(target); // Use basic attack
      return;
    }

    // ✨ Cast spell
    this.mana -= 20;
    const spellDamage = this.spellPower + Math.floor(Math.random() * 15);
    const actualDamage = Math.max(spellDamage, spellDamage - Math.floor(target.defense / 2)); // Magic partially ignores armor
    
    target.takeDamage(actualDamage);
    console.log(`✨ ${this.name} casts a spell at ${target.name} for ${actualDamage} magical damage!`);
    console.log(`🔮 Mana: ${this.mana}/${this.maxMana}`);
  }

  // 🧘‍♂️ Restore mana
  meditate(): void {
    const restored = Math.min(30, this.maxMana - this.mana);
    this.mana += restored;
    console.log(`🧘‍♂️ ${this.name} meditates and restores ${restored} mana. Current: ${this.mana}/${this.maxMana}`);
  }
}

// 🛡️ Tank with defensive abilities
class Tank extends CombatCharacter {
  shieldPoints: number;
  maxShieldPoints: number;

  constructor(name: string) {
    super(name, 150, 15, 20); // High HP, low damage, high defense
    this.shieldPoints = 50;
    this.maxShieldPoints = 50;
  }

  // 🔄 Override takeDamage to use shield
  takeDamage(damage: number): void {
    if (this.shieldPoints > 0) {
      const shieldAbsorbed = Math.min(this.shieldPoints, damage);
      this.shieldPoints -= shieldAbsorbed;
      const remainingDamage = damage - shieldAbsorbed;
      
      console.log(`🛡️ Shield absorbs ${shieldAbsorbed} damage! Shield: ${this.shieldPoints}/${this.maxShieldPoints}`);
      
      if (remainingDamage > 0) {
        super.takeDamage(remainingDamage);
      }
    } else {
      super.takeDamage(damage);
    }
  }

  // 🔄 Override attack with shield bash
  attack(target: CombatCharacter): void {
    // 🛡️ Shield bash attack
    const bashDamage = this.damage + Math.floor(this.shieldPoints / 10);
    const actualDamage = Math.max(1, bashDamage - target.defense);
    
    target.takeDamage(actualDamage);
    console.log(`🛡️ ${this.name} shield bashes ${target.name} for ${actualDamage} damage!`);
    
    // 💪 Chance to stun (simplified)
    if (Math.random() < 0.3) {
      console.log(`😵 ${target.name} is stunned by the powerful bash!`);
    }
  }

  // 🔄 Enhanced status with shield info
  getStatus(): string {
    const baseStatus = super.getStatus();
    return `${baseStatus} | 🛡️ Shield: ${this.shieldPoints}/${this.maxShieldPoints}`;
  }

  // 🛡️ Repair shield
  repairShield(): void {
    const repaired = Math.min(20, this.maxShieldPoints - this.shieldPoints);
    this.shieldPoints += repaired;
    console.log(`🔧 ${this.name} repairs shield for ${repaired} points. Shield: ${this.shieldPoints}/${this.maxShieldPoints}`);
  }
}

// 🏃‍♂️ Rogue with stealth attacks
class Rogue extends CombatCharacter {
  stealthMode: boolean = false;
  criticalChance: number = 0.3;

  constructor(name: string) {
    super(name, 100, 35, 10); // Medium HP, high damage, medium defense
  }

  // 🔄 Override attack with stealth and critical hits
  attack(target: CombatCharacter): void {
    let damage = this.damage;
    let isCritical = Math.random() < this.criticalChance;
    
    // 🌟 Stealth bonus
    if (this.stealthMode) {
      damage *= 1.5; // 50% bonus damage
      isCritical = true; // Guaranteed crit from stealth
      this.stealthMode = false; // Stealth broken after attack
      console.log(`🗡️ ${this.name} strikes from the shadows!`);
    }

    // ⚡ Critical hit
    if (isCritical) {
      damage *= 2;
      console.log(`💥 CRITICAL HIT!`);
    }

    const actualDamage = Math.max(1, damage - target.defense);
    target.takeDamage(actualDamage);
    
    const attackType = this.stealthMode ? 'sneak attacks' : 'strikes';
    console.log(`🗡️ ${this.name} ${attackType} ${target.name} for ${actualDamage} damage!`);
  }

  // 👤 Enter stealth mode
  enterStealth(): void {
    if (!this.stealthMode) {
      this.stealthMode = true;
      console.log(`👤 ${this.name} vanishes into the shadows...`);
    } else {
      console.log(`${this.name} is already in stealth mode`);
    }
  }

  // 🔄 Enhanced status with stealth info
  getStatus(): string {
    const baseStatus = super.getStatus();
    const stealthStatus = this.stealthMode ? ' | 👤 STEALTH' : '';
    return `${baseStatus}${stealthStatus}`;
  }
}

// 🎮 Epic battle simulation!
const gandalf = new Wizard('Gandalf');
const thorin = new Tank('Thorin');
const legolas = new Rogue('Legolas');

console.log('⚔️ BATTLE BEGINS! ⚔️\n');

// Display initial status
console.log('📊 Initial Status:');
console.log(gandalf.getStatus());
console.log(thorin.getStatus());
console.log(legolas.getStatus());

console.log('\n🥊 Round 1:');
legolas.enterStealth();
legolas.attack(thorin); // Sneak attack!
gandalf.attack(legolas); // Spell attack!
thorin.attack(gandalf); // Shield bash!

console.log('\n📊 After Round 1:');
console.log(gandalf.getStatus());
console.log(thorin.getStatus());
console.log(legolas.getStatus());

console.log('\n🔧 Recovery Phase:');
gandalf.meditate(); // Restore mana
thorin.repairShield(); // Fix shield
legolas.heal(15); // Drink potion

console.log('\n🥊 Round 2:');
gandalf.attack(thorin); // Spell vs tank!
thorin.attack(legolas); // Shield bash vs rogue!
legolas.attack(gandalf); // Critical strike chance!

🚗 Example 2: Vehicle Control System

Let’s create a vehicle system where different vehicles override driving behavior:

// 🚗 Base vehicle class
class Vehicle {
  make: string;
  model: string;
  year: number;
  speed: number = 0;
  maxSpeed: number;
  fuelLevel: number = 100;
  isRunning: boolean = false;

  constructor(make: string, model: string, year: number, maxSpeed: number) {
    this.make = make;
    this.model = model;
    this.year = year;
    this.maxSpeed = maxSpeed;
  }

  // 🔑 Start engine
  start(): void {
    if (!this.isRunning) {
      this.isRunning = true;
      console.log(`🔑 ${this.getVehicleName()} engine started!`);
    } else {
      console.log(`${this.getVehicleName()} is already running`);
    }
  }

  // ⏹️ Stop engine
  stop(): void {
    if (this.isRunning) {
      this.isRunning = false;
      this.speed = 0;
      console.log(`⏹️ ${this.getVehicleName()} engine stopped`);
    }
  }

  // 🚀 Accelerate - basic implementation
  accelerate(amount: number): void {
    if (!this.isRunning) {
      console.log('❌ Cannot accelerate - engine not running!');
      return;
    }

    if (this.fuelLevel <= 0) {
      console.log('⛽ Out of fuel!');
      return;
    }

    const newSpeed = Math.min(this.maxSpeed, this.speed + amount);
    const actualAcceleration = newSpeed - this.speed;
    this.speed = newSpeed;
    
    // ⛽ Consume fuel
    this.fuelLevel = Math.max(0, this.fuelLevel - (actualAcceleration * 0.5));
    
    console.log(`🚀 ${this.getVehicleName()} accelerated to ${this.speed} mph`);
    if (this.speed === this.maxSpeed) {
      console.log(`🏁 Maximum speed reached!`);
    }
  }

  // 🛑 Brake - basic implementation
  brake(amount: number): void {
    const newSpeed = Math.max(0, this.speed - amount);
    const actualDeceleration = this.speed - newSpeed;
    this.speed = newSpeed;
    
    console.log(`🛑 ${this.getVehicleName()} slowed down to ${this.speed} mph`);
    if (this.speed === 0) {
      console.log(`🛑 Vehicle stopped`);
    }
  }

  // 📊 Vehicle info
  getVehicleName(): string {
    return `${this.year} ${this.make} ${this.model}`;
  }

  // 📊 Status display
  getStatus(): string {
    const status = this.isRunning ? 'Running' : 'Stopped';
    return `🚗 ${this.getVehicleName()} | ${status} | ${this.speed}/${this.maxSpeed} mph | ⛽ ${this.fuelLevel.toFixed(1)}%`;
  }
}

// 🏎️ Sports car with turbo boost
class SportsCar extends Vehicle {
  turboMode: boolean = false;
  turboFuelConsumption: number = 2.0;

  constructor(make: string, model: string, year: number) {
    super(make, model, year, 200); // High max speed
  }

  // 🔄 Override accelerate with turbo boost
  accelerate(amount: number): void {
    if (!this.isRunning) {
      console.log('❌ Cannot accelerate - engine not running!');
      return;
    }

    if (this.fuelLevel <= 0) {
      console.log('⛽ Out of fuel!');
      return;
    }

    // 🚀 Turbo boost
    if (this.turboMode) {
      amount *= 1.5; // 50% more acceleration
      console.log('🔥 TURBO BOOST ACTIVATED!');
    }

    const newSpeed = Math.min(this.maxSpeed, this.speed + amount);
    const actualAcceleration = newSpeed - this.speed;
    this.speed = newSpeed;
    
    // ⛽ Higher fuel consumption in turbo
    const fuelConsumption = this.turboMode 
      ? actualAcceleration * this.turboFuelConsumption 
      : actualAcceleration * 0.5;
    
    this.fuelLevel = Math.max(0, this.fuelLevel - fuelConsumption);
    
    console.log(`🏎️ ${this.getVehicleName()} ${this.turboMode ? 'TURBO ' : ''}accelerated to ${this.speed} mph`);
    
    if (this.speed === this.maxSpeed) {
      console.log(`🏁 Top speed achieved! What a machine! 🔥`);
    }
  }

  // 🔄 Override brake with sport brakes
  brake(amount: number): void {
    // 🏎️ Sports cars have better brakes
    amount *= 1.3; // 30% better braking
    
    const newSpeed = Math.max(0, this.speed - amount);
    console.log(`🏎️ ${this.getVehicleName()} sport brakes engaged!`);
    
    super.brake(amount); // Use enhanced braking amount
  }

  // 🚀 Toggle turbo mode
  toggleTurbo(): void {
    if (this.fuelLevel < 20) {
      console.log('❌ Insufficient fuel for turbo mode!');
      return;
    }

    this.turboMode = !this.turboMode;
    console.log(`🔥 Turbo mode: ${this.turboMode ? 'ON' : 'OFF'}`);
  }

  // 🔄 Enhanced status with turbo info
  getStatus(): string {
    const baseStatus = super.getStatus();
    const turboStatus = this.turboMode ? ' | 🔥 TURBO' : '';
    return `${baseStatus}${turboStatus}`;
  }
}

// 🚛 Truck with cargo handling
class Truck extends Vehicle {
  cargoWeight: number = 0;
  maxCargoWeight: number = 5000; // 5000 lbs
  trailerAttached: boolean = false;

  constructor(make: string, model: string, year: number) {
    super(make, model, year, 85); // Lower max speed
  }

  // 🔄 Override accelerate considering cargo weight
  accelerate(amount: number): void {
    if (!this.isRunning) {
      console.log('❌ Cannot accelerate - engine not running!');
      return;
    }

    // 📦 Cargo affects acceleration
    const cargoFactor = 1 - (this.cargoWeight / this.maxCargoWeight) * 0.6; // Up to 60% reduction
    const trailerFactor = this.trailerAttached ? 0.7 : 1.0; // 30% reduction with trailer
    
    const adjustedAmount = amount * cargoFactor * trailerFactor;
    
    if (adjustedAmount < amount * 0.5) {
      console.log('🐌 Heavy load - slow acceleration');
    }

    // 🔄 Use parent accelerate with adjusted amount
    const oldSpeed = this.speed;
    super.accelerate(adjustedAmount);
    
    // 📦 Additional fuel consumption for cargo
    const cargoFuelPenalty = (this.cargoWeight / 1000) * 0.2;
    this.fuelLevel = Math.max(0, this.fuelLevel - cargoFuelPenalty);
    
    console.log(`🚛 Hauling ${this.cargoWeight} lbs${this.trailerAttached ? ' with trailer' : ''}`);
  }

  // 🔄 Override brake with cargo considerations
  brake(amount: number): void {
    // 🚛 Heavier loads need more distance to stop
    const cargoFactor = 1 - (this.cargoWeight / this.maxCargoWeight) * 0.4; // Reduced braking efficiency
    const adjustedAmount = amount * cargoFactor;
    
    if (cargoFactor < 0.8) {
      console.log('⚠️ Heavy load - extended braking distance!');
    }
    
    super.brake(adjustedAmount);
  }

  // 📦 Load cargo
  loadCargo(weight: number): void {
    if (this.cargoWeight + weight <= this.maxCargoWeight) {
      this.cargoWeight += weight;
      console.log(`📦 Loaded ${weight} lbs. Total cargo: ${this.cargoWeight}/${this.maxCargoWeight} lbs`);
    } else {
      console.log(`❌ Cannot load ${weight} lbs - would exceed capacity!`);
    }
  }

  // 📤 Unload cargo
  unloadCargo(weight: number): void {
    if (weight <= this.cargoWeight) {
      this.cargoWeight -= weight;
      console.log(`📤 Unloaded ${weight} lbs. Remaining cargo: ${this.cargoWeight} lbs`);
    } else {
      console.log(`❌ Cannot unload ${weight} lbs - only ${this.cargoWeight} lbs loaded`);
    }
  }

  // 🚛 Attach/detach trailer
  toggleTrailer(): void {
    this.trailerAttached = !this.trailerAttached;
    console.log(`🚛 Trailer ${this.trailerAttached ? 'attached' : 'detached'}`);
  }

  // 🔄 Enhanced status with cargo info
  getStatus(): string {
    const baseStatus = super.getStatus();
    const cargoStatus = ` | 📦 ${this.cargoWeight}/${this.maxCargoWeight} lbs`;
    const trailerStatus = this.trailerAttached ? ' | 🚛 Trailer' : '';
    return `${baseStatus}${cargoStatus}${trailerStatus}`;
  }
}

// ⚡ Electric car with battery management
class ElectricCar extends Vehicle {
  batteryLevel: number = 100; // Replace fuel with battery
  regenerativeBraking: boolean = true;
  ecoMode: boolean = false;

  constructor(make: string, model: string, year: number) {
    super(make, model, year, 120);
    this.fuelLevel = 0; // Electric cars don't use fuel
  }

  // 🔄 Override accelerate for electric efficiency
  accelerate(amount: number): void {
    if (!this.isRunning) {
      console.log('❌ Cannot accelerate - car not ready!');
      return;
    }

    if (this.batteryLevel <= 0) {
      console.log('🔋 Battery depleted!');
      return;
    }

    // ⚡ Eco mode affects acceleration
    if (this.ecoMode) {
      amount *= 0.7; // Reduced acceleration in eco mode
      console.log('🌱 Eco mode - gentle acceleration');
    }

    const newSpeed = Math.min(this.maxSpeed, this.speed + amount);
    const actualAcceleration = newSpeed - this.speed;
    this.speed = newSpeed;
    
    // 🔋 Consume battery power
    const powerConsumption = this.ecoMode 
      ? actualAcceleration * 0.3 
      : actualAcceleration * 0.5;
    
    this.batteryLevel = Math.max(0, this.batteryLevel - powerConsumption);
    
    console.log(`⚡ ${this.getVehicleName()} silently accelerated to ${this.speed} mph`);
  }

  // 🔄 Override brake with regenerative braking
  brake(amount: number): void {
    const initialSpeed = this.speed;
    
    // 🔄 Standard braking
    super.brake(amount);
    
    // 🔋 Regenerative braking recovers energy
    if (this.regenerativeBraking && initialSpeed > this.speed) {
      const energyRecovered = (initialSpeed - this.speed) * 0.3;
      this.batteryLevel = Math.min(100, this.batteryLevel + energyRecovered);
      console.log(`🔋 Regenerative braking recovered ${energyRecovered.toFixed(1)}% battery`);
    }
  }

  // 🔌 Charge battery
  charge(minutes: number): void {
    const chargeRate = 2; // 2% per minute
    const chargeAmount = minutes * chargeRate;
    const oldLevel = this.batteryLevel;
    this.batteryLevel = Math.min(100, this.batteryLevel + chargeAmount);
    const actualCharge = this.batteryLevel - oldLevel;
    
    console.log(`🔌 Charged for ${minutes} minutes. Battery: ${this.batteryLevel.toFixed(1)}% (+${actualCharge.toFixed(1)}%)`);
  }

  // 🌱 Toggle eco mode
  toggleEcoMode(): void {
    this.ecoMode = !this.ecoMode;
    console.log(`🌱 Eco mode: ${this.ecoMode ? 'ON' : 'OFF'}`);
  }

  // 🔄 Override status for electric car
  getStatus(): string {
    const status = this.isRunning ? 'Ready' : 'Parked';
    const ecoStatus = this.ecoMode ? ' | 🌱 ECO' : '';
    const regenStatus = this.regenerativeBraking ? ' | 🔋 REGEN' : '';
    return `⚡ ${this.getVehicleName()} | ${status} | ${this.speed}/${this.maxSpeed} mph | 🔋 ${this.batteryLevel.toFixed(1)}%${ecoStatus}${regenStatus}`;
  }
}

// 🚗 Let's test our vehicles!
const ferrari = new SportsCar('Ferrari', '488 GTB', 2023);
const ford = new Truck('Ford', 'F-150', 2023);
const tesla = new ElectricCar('Tesla', 'Model S', 2023);

console.log('🚗 VEHICLE TEST DRIVE 🚗\n');

// Ferrari test
console.log('=== 🏎️ Sports Car Test ===');
ferrari.start();
ferrari.accelerate(50);
ferrari.toggleTurbo();
ferrari.accelerate(30); // Turbo acceleration!
console.log(ferrari.getStatus());
ferrari.brake(40);
console.log(ferrari.getStatus());

console.log('\n=== 🚛 Truck Test ===');
ford.start();
ford.loadCargo(3000);
ford.toggleTrailer();
ford.accelerate(30); // Slow due to cargo and trailer
console.log(ford.getStatus());
ford.brake(20); // Extended braking
ford.unloadCargo(1000);
console.log(ford.getStatus());

console.log('\n=== ⚡ Electric Car Test ===');
tesla.start();
tesla.toggleEcoMode();
tesla.accelerate(40); // Eco mode acceleration
console.log(tesla.getStatus());
tesla.brake(25); // Regenerative braking
console.log(tesla.getStatus());
tesla.charge(10); // Quick charge
console.log(tesla.getStatus());

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Abstract Method Overriding

Sometimes you want to force child classes to implement specific methods:

// 🎨 Abstract media player
abstract class MediaPlayer {
  title: string;
  isPlaying: boolean = false;

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

  // 🔄 Concrete method - same for all players
  togglePlay(): void {
    if (this.isPlaying) {
      this.pause();
    } else {
      this.play();
    }
  }

  // 🎯 Abstract methods - MUST be overridden
  abstract play(): void;
  abstract pause(): void;
  abstract getDuration(): number;
  abstract getFormat(): string;
}

// 🎵 Audio player implementation
class AudioPlayer extends MediaPlayer {
  private audioData: string;
  private currentTime: number = 0;
  private duration: number;

  constructor(title: string, audioData: string, duration: number) {
    super(title);
    this.audioData = audioData;
    this.duration = duration;
  }

  // ✅ Must implement - play method
  play(): void {
    this.isPlaying = true;
    console.log(`🎵 Playing audio: "${this.title}" from ${this.currentTime}s`);
  }

  // ✅ Must implement - pause method
  pause(): void {
    this.isPlaying = false;
    console.log(`⏸️ Paused audio: "${this.title}" at ${this.currentTime}s`);
  }

  // ✅ Must implement - getDuration method
  getDuration(): number {
    return this.duration;
  }

  // ✅ Must implement - getFormat method
  getFormat(): string {
    return 'MP3 Audio 🎵';
  }
}

// 📹 Video player implementation  
class VideoPlayer extends MediaPlayer {
  private videoData: string;
  private currentFrame: number = 0;
  private totalFrames: number;
  private fps: number = 30;

  constructor(title: string, videoData: string, totalFrames: number) {
    super(title);
    this.videoData = videoData;
    this.totalFrames = totalFrames;
  }

  // ✅ Must implement - play method
  play(): void {
    this.isPlaying = true;
    console.log(`📹 Playing video: "${this.title}" from frame ${this.currentFrame}`);
  }

  // ✅ Must implement - pause method
  pause(): void {
    this.isPlaying = false;
    console.log(`⏸️ Paused video: "${this.title}" at frame ${this.currentFrame}`);
  }

  // ✅ Must implement - getDuration method
  getDuration(): number {
    return Math.round(this.totalFrames / this.fps);
  }

  // ✅ Must implement - getFormat method
  getFormat(): string {
    return `MP4 Video 📹 (${this.fps}fps)`;
  }
}

🏗️ Advanced Topic 2: Method Overriding with Generics

Combine overriding with generic types for maximum flexibility:

// 🗄️ Generic data repository
abstract class Repository<T> {
  protected items: T[] = [];

  // 📊 Common methods for all repositories
  getAll(): T[] {
    return [...this.items];
  }

  count(): number {
    return this.items.length;
  }

  // 🎯 Abstract methods to be overridden
  abstract add(item: T): void;
  abstract findById(id: string | number): T | undefined;
  abstract update(id: string | number, updates: Partial<T>): boolean;
  abstract delete(id: string | number): boolean;
}

// 👤 User repository with specific validation
interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

class UserRepository extends Repository<User> {
  private nextId: number = 1;

  // 🔄 Override add with user validation
  add(user: Omit<User, 'id'>): void {
    // 🛡️ Validate email format
    if (!user.email.includes('@')) {
      console.log('❌ Invalid email format');
      return;
    }

    // 🛡️ Check for duplicate email
    const existingUser = this.items.find(u => u.email === user.email);
    if (existingUser) {
      console.log('❌ Email already exists');
      return;
    }

    const newUser: User = { ...user, id: this.nextId++ };
    this.items.push(newUser);
    console.log(`✅ Added user: ${newUser.name} (ID: ${newUser.id})`);
  }

  // 🔄 Override findById
  findById(id: number): User | undefined {
    return this.items.find(user => user.id === id);
  }

  // 🔄 Override update with validation
  update(id: number, updates: Partial<User>): boolean {
    const userIndex = this.items.findIndex(user => user.id === id);
    if (userIndex === -1) {
      console.log('❌ User not found');
      return false;
    }

    // 🛡️ Validate email if being updated
    if (updates.email && !updates.email.includes('@')) {
      console.log('❌ Invalid email format');
      return false;
    }

    this.items[userIndex] = { ...this.items[userIndex], ...updates };
    console.log(`✅ Updated user ID ${id}`);
    return true;
  }

  // 🔄 Override delete
  delete(id: number): boolean {
    const userIndex = this.items.findIndex(user => user.id === id);
    if (userIndex === -1) {
      console.log('❌ User not found');
      return false;
    }

    const deletedUser = this.items.splice(userIndex, 1)[0];
    console.log(`🗑️ Deleted user: ${deletedUser.name}`);
    return true;
  }

  // 🔍 User-specific methods
  findByEmail(email: string): User | undefined {
    return this.items.find(user => user.email === email);
  }
}

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Changing Method Signatures

class Parent {
  greet(name: string): string {
    return `Hello, ${name}!`;
  }
}

// ❌ Wrong - changing the signature!
class BadChild extends Parent {
  greet(name: string, age: number): string { // 💥 Different signature!
    return `Hello, ${name}, age ${age}!`;
  }
}

// ✅ Correct - keep the same signature
class GoodChild extends Parent {
  greet(name: string): string { // ✅ Same signature
    return `Hey there, ${name}! Welcome!`;
  }
}

🤯 Pitfall 2: Forgetting Return Types

class Parent {
  calculate(): number {
    return 42;
  }
}

// ❌ Wrong - returning different type!
class BadChild extends Parent {
  calculate(): string { // 💥 TypeScript error!
    return "42";
  }
}

// ✅ Correct - same return type
class GoodChild extends Parent {
  calculate(): number { // ✅ Same return type
    return 84; // Different value, same type
  }
}

🔄 Pitfall 3: Breaking the Liskov Substitution Principle

class Bird {
  fly(): void {
    console.log('Flying high! 🦅');
  }
}

// ❌ Problematic - penguins can't fly!
class Penguin extends Bird {
  fly(): void {
    throw new Error('Penguins cannot fly!'); // 💥 Breaks expectations
  }
}

// ✅ Better design - composition over inheritance
interface Flyable {
  fly(): void;
}

interface Swimmable {
  swim(): void;
}

class Eagle implements Flyable {
  fly(): void {
    console.log('Soaring through the sky! 🦅');
  }
}

class Penguin implements Swimmable {
  swim(): void {
    console.log('Swimming gracefully! 🐧');
  }
}

🛠️ Best Practices

🎯 Keep Same Signatures: Don’t change parameter types or return types
📝 Follow LSP: Overridden methods should be substitutable
🔄 Use super() Wisely: Enhance rather than completely replace when possible
🛡️ Validate Consistently: Maintain or strengthen preconditions
📖 Document Changes: Make overriding behavior clear to users

🧪 Hands-On Exercise

🎯 Challenge: Build a Payment Processing System

Create a payment system where different payment methods override processing behavior:

📋 Requirements:

✅ Base PaymentProcessor class with amount, currency, fees
💳 CreditCardProcessor with validation and fraud detection
🏦 BankTransferProcessor with clearing times and limits
💰 CryptoProcessor with blockchain confirmation and volatility
🔄 Each processor should override processing methods uniquely

🚀 Bonus Points:

Add refund processing with different rules
Implement transaction logging
Create payment analytics

💡 Solution

🔍 Click to see solution

// 💳 Base payment processor
abstract class PaymentProcessor {
  amount: number;
  currency: string;
  baseFeeRate: number = 0.025; // 2.5%
  status: 'pending' | 'processing' | 'completed' | 'failed' = 'pending';
  transactionId: string;

  constructor(amount: number, currency: string = 'USD') {
    this.amount = amount;
    this.currency = currency;
    this.transactionId = `txn_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
  }

  // 💰 Calculate fees - can be overridden
  calculateFees(): number {
    return this.amount * this.baseFeeRate;
  }

  // 🔍 Validate transaction - basic validation
  validateTransaction(): boolean {
    if (this.amount <= 0) {
      console.log('❌ Invalid amount');
      return false;
    }
    if (!this.currency) {
      console.log('❌ Currency required');
      return false;
    }
    return true;
  }

  // 📊 Get transaction summary
  getTransactionSummary(): string {
    const fees = this.calculateFees();
    const total = this.amount + fees;
    return `💳 ${this.transactionId} | ${this.currency} ${this.amount.toFixed(2)} + ${fees.toFixed(2)} fees = ${total.toFixed(2)} total | Status: ${this.status.toUpperCase()}`;
  }

  // 🎯 Abstract method - must be overridden
  abstract processPayment(): Promise<boolean>;
}

// 💳 Credit card processor
class CreditCardProcessor extends PaymentProcessor {
  cardNumber: string;
  expiryDate: string;
  cvv: string;
  fraudScore: number = 0;

  constructor(amount: number, cardNumber: string, expiryDate: string, cvv: string, currency: string = 'USD') {
    super(amount, currency);
    this.cardNumber = cardNumber;
    this.expiryDate = expiryDate;
    this.cvv = cvv;
    this.baseFeeRate = 0.029; // 2.9% for credit cards
  }

  // 🔄 Override fee calculation with credit card fees
  calculateFees(): number {
    let baseFees = super.calculateFees();
    
    // 💳 Premium card types have higher fees
    if (this.cardNumber.startsWith('4')) {
      baseFees *= 1.1; // Visa surcharge
    } else if (this.cardNumber.startsWith('5')) {
      baseFees *= 1.15; // Mastercard surcharge
    }

    // 🌍 International transaction fees
    if (this.currency !== 'USD') {
      baseFees += this.amount * 0.01; // 1% international fee
    }

    return baseFees;
  }

  // 🔄 Override validation with card-specific checks
  validateTransaction(): boolean {
    // 📞 Basic validation first
    if (!super.validateTransaction()) {
      return false;
    }

    // 💳 Credit card validation
    if (this.cardNumber.length < 13 || this.cardNumber.length > 19) {
      console.log('❌ Invalid card number length');
      return false;
    }

    if (this.cvv.length < 3 || this.cvv.length > 4) {
      console.log('❌ Invalid CVV');
      return false;
    }

    // 📅 Expiry date check (simplified)
    const today = new Date();
    const [month, year] = this.expiryDate.split('/');
    const expiryDate = new Date(2000 + parseInt(year), parseInt(month) - 1);
    
    if (expiryDate < today) {
      console.log('❌ Card expired');
      return false;
    }

    return true;
  }

  // 🛡️ Fraud detection
  private performFraudCheck(): boolean {
    // 🔍 Simplified fraud scoring
    this.fraudScore = 0;

    // Large amount risk
    if (this.amount > 1000) this.fraudScore += 20;
    if (this.amount > 5000) this.fraudScore += 30;

    // International transaction risk
    if (this.currency !== 'USD') this.fraudScore += 15;

    // Velocity check (simplified - in reality would check recent transactions)
    if (Math.random() < 0.1) this.fraudScore += 25; // Random velocity hit

    console.log(`🔍 Fraud score: ${this.fraudScore}/100`);

    if (this.fraudScore > 50) {
      console.log('🚨 High fraud risk - transaction blocked');
      return false;
    }

    return true;
  }

  // 🔄 Override payment processing
  async processPayment(): Promise<boolean> {
    console.log(`💳 Processing credit card payment: ${this.getTransactionSummary()}`);
    
    this.status = 'processing';

    // 🛡️ Validation
    if (!this.validateTransaction()) {
      this.status = 'failed';
      return false;
    }

    // 🔍 Fraud check
    if (!this.performFraudCheck()) {
      this.status = 'failed';
      return false;
    }

    // 💳 Simulate card processing
    console.log('💳 Contacting card issuer...');
    await new Promise(resolve => setTimeout(resolve, 1000));

    // 🎲 Simulate approval (90% success rate)
    if (Math.random() < 0.9) {
      this.status = 'completed';
      console.log('✅ Credit card payment approved!');
      console.log(`💳 Charged ${this.cardNumber.slice(-4)} for ${this.currency} ${(this.amount + this.calculateFees()).toFixed(2)}`);
      return true;
    } else {
      this.status = 'failed';
      console.log('❌ Credit card payment declined');
      return false;
    }
  }

  // 💳 Card-specific method
  getMaskedCardNumber(): string {
    return `****-****-****-${this.cardNumber.slice(-4)}`;
  }
}

// 🏦 Bank transfer processor
class BankTransferProcessor extends PaymentProcessor {
  bankAccountNumber: string;
  routingNumber: string;
  accountType: 'checking' | 'savings';
  dailyLimit: number = 10000;
  processingTime: number = 1; // 1 day

  constructor(amount: number, bankAccountNumber: string, routingNumber: string, accountType: 'checking' | 'savings', currency: string = 'USD') {
    super(amount, currency);
    this.bankAccountNumber = bankAccountNumber;
    this.routingNumber = routingNumber;
    this.accountType = accountType;
    this.baseFeeRate = 0.01; // 1% for bank transfers
  }

  // 🔄 Override fee calculation - lower fees but flat rate for large amounts
  calculateFees(): number {
    const percentageFee = super.calculateFees();
    const flatFee = 5.00; // $5 flat fee
    
    // 🏦 Use flat fee for large amounts if it's cheaper
    if (this.amount > 2000) {
      return Math.min(percentageFee, flatFee);
    }
    
    return Math.max(percentageFee, flatFee); // Minimum $5 fee
  }

  // 🔄 Override validation with bank-specific checks
  validateTransaction(): boolean {
    if (!super.validateTransaction()) {
      return false;
    }

    // 🏦 Bank account validation
    if (this.bankAccountNumber.length < 8 || this.bankAccountNumber.length > 12) {
      console.log('❌ Invalid account number length');
      return false;
    }

    if (this.routingNumber.length !== 9) {
      console.log('❌ Invalid routing number');
      return false;
    }

    // 💰 Daily limit check
    if (this.amount > this.dailyLimit) {
      console.log(`❌ Amount exceeds daily limit of $${this.dailyLimit.toLocaleString()}`);
      return false;
    }

    return true;
  }

  // 🔄 Override payment processing with bank clearing
  async processPayment(): Promise<boolean> {
    console.log(`🏦 Processing bank transfer: ${this.getTransactionSummary()}`);
    
    this.status = 'processing';

    if (!this.validateTransaction()) {
      this.status = 'failed';
      return false;
    }

    // 🏦 Simulate bank verification
    console.log('🏦 Verifying bank account...');
    await new Promise(resolve => setTimeout(resolve, 800));

    console.log(`⏳ Bank transfer initiated - will clear in ${this.processingTime} business day(s)`);
    
    // 🎲 Very high success rate for bank transfers
    if (Math.random() < 0.95) {
      this.status = 'completed';
      console.log('✅ Bank transfer authorized!');
      console.log(`🏦 Debiting account ****${this.bankAccountNumber.slice(-4)} for ${this.currency} ${(this.amount + this.calculateFees()).toFixed(2)}`);
      return true;
    } else {
      this.status = 'failed';
      console.log('❌ Bank transfer failed - insufficient funds');
      return false;
    }
  }

  // 🏦 Bank-specific method
  getAccountSummary(): string {
    return `${this.accountType.toUpperCase()} ****${this.bankAccountNumber.slice(-4)} (Routing: ${this.routingNumber})`;
  }
}

// ₿ Cryptocurrency processor
class CryptoProcessor extends PaymentProcessor {
  walletAddress: string;
  cryptoCurrency: 'BTC' | 'ETH' | 'USDC';
  networkFees: number = 0;
  confirmationsRequired: number = 3;
  volatilityRisk: number = 0.05; // 5% volatility buffer

  constructor(amount: number, walletAddress: string, cryptoCurrency: 'BTC' | 'ETH' | 'USDC', currency: string = 'USD') {
    super(amount, currency);
    this.walletAddress = walletAddress;
    this.cryptoCurrency = cryptoCurrency;
    this.baseFeeRate = 0.015; // 1.5% for crypto
    
    // 🌐 Set network fees based on crypto type
    this.networkFees = cryptoCurrency === 'BTC' ? 15 : cryptoCurrency === 'ETH' ? 25 : 2;
  }

  // 🔄 Override fee calculation with network fees and volatility
  calculateFees(): number {
    const baseFees = super.calculateFees();
    const volatilityBuffer = this.amount * this.volatilityRisk;
    
    console.log(`₿ Base fees: $${baseFees.toFixed(2)}, Network fees: $${this.networkFees}, Volatility buffer: $${volatilityBuffer.toFixed(2)}`);
    
    return baseFees + this.networkFees + volatilityBuffer;
  }

  // 🔄 Override validation with crypto-specific checks
  validateTransaction(): boolean {
    if (!super.validateTransaction()) {
      return false;
    }

    // ₿ Wallet address validation (simplified)
    if (this.walletAddress.length < 26 || this.walletAddress.length > 62) {
      console.log('❌ Invalid wallet address format');
      return false;
    }

    // 💰 Minimum amount for crypto (due to network fees)
    if (this.amount < 10) {
      console.log('❌ Minimum transaction amount is $10 for crypto payments');
      return false;
    }

    return true;
  }

  // ₿ Get current crypto rate (simulated)
  private getCryptoRate(): number {
    const basRates = { BTC: 45000, ETH: 3000, USDC: 1 };
    const baseRate = baseRates[this.cryptoCurrency];
    
    // 📈 Add some volatility
    const volatility = (Math.random() - 0.5) * 0.1; // ±5% volatility
    return baseRate * (1 + volatility);
  }

  // 🔄 Override payment processing with blockchain
  async processPayment(): Promise<boolean> {
    console.log(`₿ Processing crypto payment: ${this.getTransactionSummary()}`);
    
    this.status = 'processing';

    if (!this.validateTransaction()) {
      this.status = 'failed';
      return false;
    }

    // ₿ Get current rates
    const cryptoRate = this.getCryptoRate();
    const cryptoAmount = (this.amount + this.calculateFees()) / cryptoRate;
    
    console.log(`₿ Converting ${this.currency} ${(this.amount + this.calculateFees()).toFixed(2)} to ${cryptoAmount.toFixed(8)} ${this.cryptoCurrency}`);
    console.log(`₿ Current rate: 1 ${this.cryptoCurrency} = $${cryptoRate.toFixed(2)}`);

    // 🌐 Simulate blockchain transaction
    console.log('🌐 Broadcasting transaction to blockchain...');
    await new Promise(resolve => setTimeout(resolve, 1200));

    console.log(`⏳ Waiting for ${this.confirmationsRequired} confirmations...`);
    
    // 🎲 High success rate but some network issues possible
    if (Math.random() < 0.88) {
      this.status = 'completed';
      console.log('✅ Crypto payment confirmed on blockchain!');
      console.log(`₿ Sent ${cryptoAmount.toFixed(8)} ${this.cryptoCurrency} to ${this.walletAddress.slice(0, 8)}...`);
      return true;
    } else {
      this.status = 'failed';
      console.log('❌ Crypto payment failed - network congestion');
      return false;
    }
  }

  // ₿ Crypto-specific method
  getWalletSummary(): string {
    return `${this.cryptoCurrency} wallet: ${this.walletAddress.slice(0, 8)}...${this.walletAddress.slice(-8)}`;
  }
}

// 💳 Payment processor factory
class PaymentProcessorFactory {
  static createProcessor(type: 'credit_card' | 'bank_transfer' | 'crypto', amount: number, ...args: any[]): PaymentProcessor {
    switch (type) {
      case 'credit_card':
        return new CreditCardProcessor(amount, ...args);
      case 'bank_transfer':
        return new BankTransferProcessor(amount, ...args);
      case 'crypto':
        return new CryptoProcessor(amount, ...args);
      default:
        throw new Error('Unknown payment processor type');
    }
  }
}

// 🎮 Let's process some payments!
async function runPaymentDemo() {
  console.log('💳 PAYMENT PROCESSING DEMO 💳\n');

  // Create different payment processors
  const creditCard = new CreditCardProcessor(299.99, '4111111111111111', '12/25', '123');
  const bankTransfer = new BankTransferProcessor(1500.00, '123456789012', '021000021', 'checking');
  const crypto = new CryptoProcessor(750.00, 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh', 'BTC');

  console.log('=== Payment Summaries ===');
  console.log(creditCard.getTransactionSummary());
  console.log(bankTransfer.getTransactionSummary());
  console.log(crypto.getTransactionSummary());

  console.log('\n=== Processing Credit Card Payment ===');
  await creditCard.processPayment();

  console.log('\n=== Processing Bank Transfer ===');
  await bankTransfer.processPayment();

  console.log('\n=== Processing Crypto Payment ===');
  await crypto.processPayment();

  console.log('\n=== Final Status ===');
  console.log(`💳 Credit Card: ${creditCard.status.toUpperCase()}`);
  console.log(`🏦 Bank Transfer: ${bankTransfer.status.toUpperCase()}`);
  console.log(`₿ Crypto: ${crypto.status.toUpperCase()}`);
}

// Run the demo
runPaymentDemo();

🎓 Key Takeaways

You’ve mastered method overriding! Here’s what you can now do:

✅ Override methods effectively while keeping signatures 🔄
✅ Combine overriding with super calls for enhancement 🚀
✅ Create polymorphic behavior with consistent interfaces 🎭
✅ Validate and handle edge cases in overridden methods 🛡️
✅ Avoid common overriding pitfalls like a pro 🎯

Remember: Method overriding is about customization, not replacement - enhance what works! 🌟

🤝 Next Steps

Congratulations! 🎉 You’ve mastered method overriding in TypeScript!

Here’s what to do next:

💻 Practice with the payment processing exercise above
🏗️ Build your own system with different overriding patterns
📚 Move on to our next tutorial: Abstract Classes and Methods: Creating Base Classes
🌟 Experiment with combining overriding, generics, and interfaces!

Remember: Every great object-oriented system uses method overriding effectively. Keep customizing, keep learning, and override your way to better code! 🚀

Happy coding! 🎉🚀✨

Prerequisites

What you'll learn