Ereditarietà in

Informazioni su Ereditarietà

L'ereditarietà è un modo per creare relazioni padre-figlio tra le classi. La classe figlia (a volte chiamata sottoclasse) ha accesso al comportamento e ai dati definiti dalla classe padre (a volte chiamata superclasse).

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

  introduce() {
    console.log(`This is my pet, ${this.name}.`);
  }
}

class Dog extends Pet {}

const dog = new Dog('Otis');
dog.introduce();
// => This is my pet, Otis.

La parola chiave extends nella dichiarazione della classe figlia stabilisce una relazione con la classe padre attraverso la catena di prototipi.

Gli oggetti creati dal costruttore della classe figlia avranno il prototipo della classe padre nella loro catena di prototipi, il che dà accesso a qualsiasi metodo o dato definito dalla classe padre.

const dog = new Dog('Otis');

Dog.prototype.isPrototypeOf(dog); // => true
Pet.prototype.isPrototypeOf(dog); // => true
Pet.prototype.isPrototypeOf(Dog.prototype); // => true

Pet.prototype.hasOwnProperty('introduce'); // => true
Dog.prototype.hasOwnProperty('introduce'); // => false
dog.hasOwnProperty('introduce'); // => false

I costruttori

Se la classe figlia non definisce una funzione costruttrice, viene usata quella della classe padre. Tuttavia, se la classe figlia definisce una propria funzione costruttrice, il costruttore della classe padre deve essere chiamato esplicitamente. Per chiamare il costruttore della classe padre dallo scope del costruttore della classe figlia, si usa la parola chiave super.

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

class Dog extends Pet {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }
}

const dog = new Dog('Otis', 'Pug');

Poiché il costruttore della classe padre è responsabile dell'inizializzazione di un nuovo oggetto e della sua assegnazione a this, deve essere chiamato prima che this venga usato dal costruttore della classe figlia.

class Dog extends Pet {
  constructor(name, breed) {
    // using 'this' before calling the parent constructor with 'super'
    this.breed = breed;
    super(name);
  }
}

const dog = new Dog('Otis', 'Pug');
// => ReferenceError: Must call super constructor in derived class before accessing 'this'...

Definire metodi sulla classe figlia

Una classe figlia può definire un proprio comportamento, oltre a quello ereditato dalla classe padre.

Questo è uno dei motivi principali per usare l'ereditarietà: avere classi figlie specializzate, con dati e metodi propri, collegate tra loro tramite metodi e dati condivisi forniti dalla classe padre.

class Dog extends Pet {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  describe() {
    console.log(`${this.name} is a ${this.breed}.`);
  }
}

const dog = new Dog('Otis', 'Pug');
dog.introduce();
dog.describe();
// => 'This is my pet, Otis.'
// => 'Otis is a Pug.'

Sovrascrivere i metodi ereditati dalla classe padre

Una classe figlia può anche sovrascrivere il comportamento di un metodo definito dalla classe padre e sostituirlo o estenderlo con un comportamento definito dalla classe figlia.

class Cat extends Pet {
  // replacing parent class behavior
  introduce() {
    console.log(`This is my cat, ${this.name}.`);
  }
}

class Dog extends Pet {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  describe() {
    console.log(`${this.name} is a ${this.breed}.`);
  }

  // extending parent class behavior
  introduce() {
    super.introduce();
    this.describe();
  }
}

const cat = new Cat('Milo');
cat.introduce();
// => 'This is my cat, Milo.'

const dog = new Dog('Otis', 'Pug');
dog.introduce();
// => This is my pet, Otis.
// => Otis is a Pug.

Per chiamare un metodo definito sulla classe padre dal corpo di un metodo con lo stesso nome sulla classe figlia, si deve usare la parola chiave super per fare riferimento alla classe padre.