Inheritance

Base class vs. derived class

The base class (also called the parent or superclass) holds the shared, general behavior — here, Animal. A derived class (the child or subclass) extends it — Dog, Cat, Bird. The derived class starts with everything the base has, then layers its own changes on top.

In most languages you spell this with the extends keyword. class Dog extends Animal reads almost like English: a Dog extends what an Animal already is.

Inheriting fields and methods

Because Dog extends Animal, every Dog automatically has a name field and can eat() and sleep() — you didn't rewrite any of that. Call myDog.eat() and it runs the exact code defined up in Animal. That's inheritance: the child reuses the parent's members as if they were its own.

class Animal {
  constructor(public name: string) {}

  eat() {
    return this.name + " is eating";
  }

  makeSound() {
    return "(some generic animal noise)";
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);          // run Animal's constructor first
  }

  // OWN method — only dogs have this
  fetch() {
    return this.name + " fetches the ball";
  }

  // OVERRIDE — replaces Animal's makeSound for dogs
  makeSound() {
    return "Woof!";
  }
}

const d = new Dog("Rex");
d.eat();        // inherited from Animal → "Rex is eating"
d.makeSound();  // overridden by Dog     → "Woof!"
d.fetch();      // Dog's own method      → "Rex fetches the ball"

Calling the parent with `super`

When a subclass has its own constructor, it must first set up the part of the object that the parent owns. super(name) calls the parent's constructor so the inherited name field gets initialized before the child adds anything. You can also use super.someMethod() inside an override to reuse the parent's version and add to it, rather than replacing it entirely.

Overriding vs. inheriting

If a subclass defines a method with the same name as one in the parent, the subclass's version overrides it. After that, calling the method on a Dog runs the Dog version — "Woof!" — not the generic Animal one. Methods the subclass doesn't redefine are simply inherited and run the parent's code unchanged. So a Dog inherits eat() and sleep() but overrides makeSound().

Single vs. multiple inheritance

Some languages let a class inherit from only one parent — Java and C# are single-inheritance (you then mix in extra capabilities through interfaces). Others, like C++ and Python, allow multiple inheritance, where a class can extend several parents at once. Multiple inheritance is powerful but can get confusing when two parents define the same method, so single inheritance plus interfaces is the more common default.

When inheritance is the right tool

• When the relationship is a genuine is-a — a Dog is an Animal, a SavingsAccount is a BankAccount. Say it aloud; if it sounds wrong, it probably is.
• When several types share real, common behavior that you want to define once in a parent and reuse everywhere.
• When you want polymorphism — treating different subclasses uniformly through the parent type (loop over a list of Animal and call makeSound() on each).