JavaScript Inheritance – extends and super

class Animal {
  constructor(name, species) {
    this.name    = name;
    this.species = species;
    this.energy  = 100;
  }

  eat(food) {
    this.energy += 10;
    return `${this.name} eats ${food}. Energy: ${this.energy}`;
  }

  toString() {
    return `[${this.species}] ${this.name}`;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name, 'Canis lupus familiaris'); // required before this
    this.breed = breed;
  }

  bark() {
    this.energy -= 5;
    return `${this.name} barks! Energy: ${this.energy}`;
  }
}

const rex = new Dog('Rex', 'German Shepherd');
console.log(rex.toString());   // inherited from Animal
console.log(rex.eat('bone'));  // inherited method
console.log(rex.bark());       // own method

class Animal {
  constructor(name) {
    this.name = name;
  }
  describe() {
    return `I am ${this.name}`;
  }
  sound() {
    return '...';
  }
}

class Cat extends Animal {
  constructor(name, indoor) {
    super(name);
    this.indoor = indoor;
  }

  // Override: extends the parent version
  describe() {
    const base = super.describe();   // call parent
    return `${base}, a ${this.indoor ? 'indoor' : 'outdoor'} cat`;
  }

  // Override: fully replaces parent
  sound() {
    return 'Meow!';
  }
}

class Lion extends Cat {
  constructor(name) {
    super(name, false);  // outdoor
  }

  sound() {
    return 'ROAR!';   // overrides Cat.sound()
  }
}

const kitty = new Cat('Kitty', true);
const simba = new Lion('Simba');

console.log(kitty.describe());   // uses super
console.log(kitty.sound());
console.log(simba.describe());   // inherits Cat.describe
console.log(simba.sound());      // Lion.sound

class A {}
class B extends A {}
class C extends B {}

const c = new C();

console.log(c instanceof C);        // true
console.log(c instanceof B);        // true
console.log(c instanceof A);        // true
console.log(c instanceof Object);   // true (everything inherits Object)

// Walking the chain manually
let proto = Object.getPrototypeOf(c);
while (proto !== null) {
  console.log(proto.constructor.name);
  proto = Object.getPrototypeOf(proto);
}
// C → B → A → Object

class Animal {
  constructor(name) { this.name = name; }
  eat()  { return `${this.name} is eating.`; }
  sleep(){ return `${this.name} is sleeping.`; }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }
  bark() { return `${this.name} barks: Woof!`; }
}

class ServiceDog extends Dog {
  constructor(name, breed, role) {
    super(name, breed);
    this.role = role;
    this.onDuty = false;
  }

  startDuty() {
    this.onDuty = true;
    return `${this.name} (${this.role}) is now on duty.`;
  }

  assist(person) {
    if (!this.onDuty) return `${this.name} is off duty.`;
    return `${this.name} assists ${person} as a ${this.role}.`;
  }
}

const lassie = new ServiceDog('Lassie', 'Collie', 'Search & Rescue');
console.log(lassie.eat());           // from Animal
console.log(lassie.bark());          // from Dog
console.log(lassie.startDuty());     // from ServiceDog
console.log(lassie.assist('John'));  // from ServiceDog

// Mixin factories – return objects with methods
const Serializable = (Base) => class extends Base {
  serialize()   { return JSON.stringify(this); }
  static deserialize(json) { return Object.assign(new this(), JSON.parse(json)); }
};

const Timestamped = (Base) => class extends Base {
  constructor(...args) {
    super(...args);
    this.createdAt = new Date().toISOString();
  }
};

class Entity {
  constructor(id) { this.id = id; }
}

class User extends Timestamped(Serializable(Entity)) {
  constructor(id, name) {
    super(id);
    this.name = name;
  }
}

const u = new User(1, 'Alice');
console.log(u.serialize());
console.log(u.createdAt.slice(0, 10));  // today's date