Inheritance in JavaScript: Reusing Properties and Methods Across Objects

class Animal {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  } describe() {
    return `${this.name} is ${this.age} years old 🐾`;
  }
}class Penguin extends Animal {
  swim() {
    return `${this.name} is swimming! 🐧💦`;
  }
}const penny = new Penguin("Penny", 3);
console.log(penny.describe());
// "Penny is 3 years old 🐾" — inherited ✅
console.log(penny.swim());
// "Penny is swimming! 🐧💦" — its own ✅

1. Does penny itself have "describe"? ❌2. Does Penguin.prototype have it? ❌3. Does Animal.prototype have it? ✅ FOUND — run it!

class ElectricCar extends Vehicle {
  constructor(brand, batteryKwh) {
    super(brand);
    // ☎️ parent's constructor FIRST
    this.batteryKwh = batteryKwh;
    // THEN the child's own setup
  }
}

class ElectricCar extends Vehicle {
  constructor(brand, batteryKwh) {
    this.brand = brand;
    // ❌ ReferenceError! this doesn't exist yet…
    super(brand);
    // …until super() creates it
  }
}

class Animal {
  speak() {
    return "…some sound…";
  }
}class Dog extends Animal {
  speak() {
    const base = super.speak();
    // ☎️ borrow the parent's version
    return `${base} Woof! 🐕`;
    // …and extend it
  }
}console.log(new Dog().speak());
// "…some sound… Woof! 🐕" ✅

class Animal {
  speak() {
    return "…generic sound…";
  }
}class Dog extends Animal {
  speak() {
    return "Woof! 🐕";
  } // overrides Animal's
}class Cat extends Animal {
  speak() {
    return "Meow! 🐈";
  } // overrides Animal's
}class Cow extends Animal {
  // no override — keeps the parent's
}const choir =[new Dog(), new Cat(), new Cow()];
choir.forEach(a => console.log(a.speak()));
// Woof! 🐕
// Meow! 🐈
// …generic sound…        ← parent's version survived here

class Vehicle {
  wheels = 4;
}class Motorcycle extends Vehicle {
  wheels = 2;
  // 🏍️ overridden field
}console.log(new Motorcycle().wheels);
// 2 ✅

const leo = new Lion("Leo", 5);

leo(the instance)↓__proto__ linkLion.prototype ← roar() lives here↓__proto__ linkAnimal.prototype ← eat(), sleep() live here ✅ found!↓__proto__ linkObject.prototype ← toString(), hasOwnProperty() live here↓__proto__ linknull ← the end of the road 🛑

console.log(Object.getPrototypeOf(leo) === Lion.prototype);
// true
console.log(Object.getPrototypeOf(Lion.prototype) === Animal.prototype);
// true ✅
console.log(leo instanceof Lion);
// true
console.log(leo instanceof Animal);
// true — the chain proves family! 🧬
console.log(leo instanceof Object);
// true — everyone descends from Object

const arr =[1, 2, 3];
arr.map(x => x);
// ← found on Array.prototype
arr.hasOwnProperty("x");
// ← found on Object.prototype — arrays inherit it!

class Animal {
  breathe() {
    return "breathing… 💨";
  }
}class Mammal extends Animal {
  feedYoung() {
    return "nursing 🍼";
  }
}class Dog extends Mammal {
  fetch() {
    return "fetching! 🎾";
  }
}const rex = new Dog();
console.log(rex.fetch());
// Dog's own
console.log(rex.feedYoung());
// from Mammal (grandparent) ✅
console.log(rex.breathe());
// from Animal (great-grandparent) ✅

Animal → Mammal → Canine → PetDog → RescueDog → CertifiedRescueDog 😵

// 🧩 Capabilities as reusable pieces:
const canSwim = {
  swim() {
    return `${this.name} swims! 🏊`;
  }
};
const canFly = {
  fly() {
    return `${this.name} flies! 🦅`;
  }
};
class Bird {
  constructor(name) {
    this.name = name;
  }
}class Penguin extends Bird {
}Object.assign(Penguin.prototype, canSwim);
// 🧩 give penguins swimming
class Duck extends Bird {
}Object.assign(Duck.prototype, canSwim, canFly);
// 🧩 ducks get BOTH!
console.log(new Penguin("Penny").swim());
// "Penny swims! 🏊" ✅
console.log(new Duck("Donald").fly());
// "Donald flies! 🦅" ✅

// 🦁 Zoo Management — inheritance, super, overriding, composition
class Animal {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  } describe() {
    return `${this.name} (${this.constructor.name}, age ${this.age})`;
  } speak() {
    return "…";
  }
}// 🧩 Composed capability:
const canPerformTricks = {
  doTrick() {
    return `${this.name} does a backflip! 🤸`;
  }
};
class Lion extends Animal {
  speak() {
    // 🎭 override
    return "ROAAAR! 🦁";
  }
}class Penguin extends Animal {
  speak() {
    return `${super.speak()} …squawk! 🐧`;
    // ☎️ extend the parent's
  } swim() {
    return `${this.name} dives in! 💦`;
    // child's own
  }
}class Parrot extends Animal {
}Object.assign(Parrot.prototype, canPerformTricks);
// 🧩 composed skill
const animals =[ new Lion("Leo", 5), new Penguin("Penny", 3), new Parrot("Rio", 2)];
// 🎪 Polymorphism parade — one loop, every behavior:
animals.forEach(a => console.log(`${a.describe()} says: ${a.speak()}`));
console.log(new Penguin("Penny", 3).swim());
// Penguin-only skill
console.log(new Parrot("Rio", 2).doTrick());
// composed skill ✅
console.log(new Lion("Leo", 5) instanceof Animal);
// true

Leo(Lion, age 5) says: ROAAAR! 🦁Penny(Penguin, age 3) says: … …squawk! 🐧Rio(Parrot, age 2) says: …Penny dives in! 💦Rio does a backflip! 🤸true

Leo(Lion, age 5) says: ROAAAR! 🦁Penny(Penguin, age 3) says: … …squawk! 🐧Rio(Parrot, age 2) says: …Penny dives in! 💦Rio does a backflip! 🤸true