Explain the difference between classical inheritance and prototypal inheritance

TL;DR

Classical inheritance is a model where classes inherit from other classes, typically seen in languages like Java and C++. Prototypal inheritance, used in JavaScript, involves objects inheriting directly from other objects. In classical inheritance, you define a class and create instances from it. In prototypal inheritance, you create an object and use it as a prototype for other objects.

Difference between classical inheritance and prototypal inheritance

Classical inheritance

Classical inheritance is a pattern used in many object-oriented programming languages like Java, C++, and Python. It involves creating a class hierarchy where classes inherit properties and methods from other classes.

Class definition: You define a class with properties and methods.
Instantiation: You create instances (objects) of the class.
Inheritance: A class can inherit from another class, forming a parent-child relationship.

Example in Java:

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // Inherited method
        dog.bark(); // Own method
    }
}

Prototypal inheritance

Prototypal inheritance is a feature of JavaScript where objects inherit directly from other objects. There are no classes; instead, objects serve as prototypes for other objects.

Object creation: You create an object directly.
Prototype chain: Objects can inherit properties and methods from other objects through the prototype chain.
Flexibility: You can dynamically add or modify properties and methods.

Example in JavaScript:

const animal = {
  eat() {
    console.log('This animal eats food.');
  },
};

const dog = Object.create(animal);
dog.bark = function () {
  console.log('The dog barks.');
};

dog.eat(); // Inherited method
dog.bark(); // Own method

Key differences

Class-based vs. prototype-based: Classical inheritance uses classes, while prototypal inheritance uses objects.
Inheritance model: Classical inheritance forms a class hierarchy, whereas prototypal inheritance forms a prototype chain.
Flexibility: Prototypal inheritance is more flexible and dynamic, allowing for changes at runtime.