What is the difference between classical inheritance and prototypal inheritance?

Classical inheritance and prototypal inheritance are two different approaches to object-oriented programming in JavaScript.

Classical inheritance involves creating a blueprint for an object, known as a class, which defines its properties and methods. Instances of the class are then created using the "new" keyword. In classical inheritance, objects inherit from their parent class, and can override or extend its properties and methods. This approach is commonly used in languages like Java and C++. An example of classical inheritance in JavaScript:

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const d = new Dog('Mitzie');
d.speak(); // Output: "Mitzie barks."

Prototypal inheritance, on the other hand, involves creating objects that inherit directly from other objects, known as prototypes. In this approach, there are no classes, and objects can be created and modified dynamically. Prototypal inheritance is a core feature of JavaScript, and is used extensively in the language's built-in objects. An example of prototypal inheritance in JavaScript:

const animal = {
  speak() {
    console.log(`${this.name} makes a noise.`);
  }
};

const dog = Object.create(animal);
dog.name = 'Mitzie';
dog.speak(); // Output: "Mitzie makes a noise."

In summary, classical inheritance involves creating classes and instances, while prototypal inheritance involves creating objects that inherit directly from other objects. Both approaches have their own strengths and weaknesses, and the choice between them depends on the specific requirements of the project.