Class Inheritance

Inheritance lets one class reuse the properties and methods of another, so you don't have to duplicate shared logic across multiple similar classes. If you have several kinds of things that are all fundamentally the same but with a few differences — say, different kinds of Animal, or different kinds of Employee — you can put the shared behavior in a base class and let more specific classes build on top of it, adding or overriding only what's different.

The extends keyword is placed after a class name to indicate it inherits from another class. The class doing the inheriting is usually called the child, subclass, or derived class; the class being inherited from is the parent, superclass, or base class. Every instance method and property defined on the parent becomes available to instances of the child, without having to be rewritten.

When a subclass defines its own constructor, it must call super(...) before it can use this — super() calls the parent class's constructor, which is what actually creates and initializes the instance. Skipping this call, or trying to use this before calling it, throws a ReferenceError. Whatever arguments the parent constructor expects should be passed through super(...).

A subclass can override an inherited method simply by defining a method with the same name. When that method is called on an instance of the subclass, JavaScript uses the subclass's version instead of the parent's — this is normal method overriding, and it's how different subclasses can customize shared behavior while keeping the same method name.

Sometimes you don't want to fully replace a parent's method — you want to extend it, running the parent's original logic and then adding something extra. Inside an overriding method, super.methodName() calls the parent class's version of that same method, letting you build on top of it instead of duplicating its logic.

When you write class Dog extends Animal, JavaScript links Dog.prototype's internal prototype to Animal.prototype. So when you call rex.speak() and Dog.prototype doesn't have a speak() method, the JavaScript engine walks up this chain — from rex, to Dog.prototype, to Animal.prototype — until it finds one. This chain of linked prototypes is exactly what makes inheritance work, and extends is simply a convenient way of wiring it up for you.

The instanceof operator checks whether an object exists anywhere along a particular constructor’s prototype chain, returning true or false. An instance of a subclass is an instanceof both the subclass and every class it inherits from, all the way up the chain.