Programmazione D - Ereditarietà

Uno dei concetti più importanti nella programmazione orientata agli oggetti è l'ereditarietà. L'ereditarietà consente di definire una classe in termini di un'altra classe, il che semplifica la creazione e la manutenzione di un'applicazione. Ciò offre anche l'opportunità di riutilizzare la funzionalità del codice e tempi di implementazione rapidi.

Quando si crea una classe, invece di scrivere membri dati e funzioni membro completamente nuovi, il programmatore può designare che la nuova classe erediti i membri di una classe esistente. Questa classe esistente è chiamatabase class e la nuova classe è indicata come derived classe.

L'idea di eredità implementa la è una relazione. Ad esempio, mammifero È-A animale, cane È-A mammifero quindi anche cane È-A animale e così via.

Classi di base e classi derivate in D

Una classe può essere derivata da più classi, il che significa che può ereditare dati e funzioni da più classi base. Per definire una classe derivata, utilizziamo un elenco di derivazione della classe per specificare la o le classi di base. Un elenco di derivazione di classi nomina una o più classi di base e ha la forma:

class derived-class: base-class

Considera una classe base Shape e la sua classe derivata Rectangle come segue -

import std.stdio;

// Base class 
class Shape { 
   public: 
      void setWidth(int w) { 
         width = w; 
      }

      void setHeight(int h) { 
         height = h; 
      }
   
   protected: 
      int width; 
      int height; 
}
  
// Derived class 
class Rectangle: Shape { 
   public: 
      int getArea() { 
         return (width * height); 
      } 
}
  
void main() { 
   Rectangle Rect = new Rectangle();
   
   Rect.setWidth(5); 
   Rect.setHeight(7); 
   
   // Print the area of the object. 
   writeln("Total area: ", Rect.getArea()); 
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Total area: 35

Controllo degli accessi ed ereditarietà

Una classe derivata può accedere a tutti i membri non privati della sua classe base. Pertanto, i membri della classe base che non dovrebbero essere accessibili alle funzioni membro delle classi derivate dovrebbero essere dichiarati privati nella classe base.

Una classe derivata eredita tutti i metodi della classe base con le seguenti eccezioni:

Costruttori, distruttori e costruttori di copia della classe base.
Operatori sovraccaricati della classe base.

Ereditarietà multilivello

L'eredità può essere di più livelli ed è mostrata nell'esempio seguente.

import std.stdio;

// Base class 
class Shape {
   public:
      void setWidth(int w) {
         width = w; 
      }

      void setHeight(int h) {
         height = h; 
      }

   protected: 
      int width; 
      int height; 
}

// Derived class 
class Rectangle: Shape {
   public:
      int getArea() {
         return (width * height); 
      }
}
 
class Square: Rectangle {
   this(int side) {
      this.setWidth(side); 
      this.setHeight(side); 
   }
}

void main() {
   Square square = new Square(13);

   // Print the area of the object.
   writeln("Total area: ", square.getArea());
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Total area: 169