Esplorazione dell'ereditarietà e delle classi astratte

L'ereditarietà e le classi astratte sono due importanti costrutti di programmazione che si trovano nei linguaggi di programmazione orientati agli oggetti. Questi concetti vengono usati per creare relazioni padre-figlio tra le classi. L'ereditarietà consente a una sottoclasse di estendere una superclasse. La sottoclasse eredita tutti gli attributi e i metodi della superclasse. Le sottoclassi possono anche sostituire il comportamento o aggiungere più funzionalità ai metodi ereditati dalla superclasse.

Ereditarietà

Per comprendere meglio il concetto di ereditarietà nella programmazione orientata agli oggetti, esaminiamo un esempio del mondo reale. In questo esempio, Veicolo è la classe padre. Esistono molti tipi diversi di veicoli, ad esempio: automobili, autobus e autocarri. In questo scenario, Veicolo è la classe padre. Automobili, autobus e autocarri sono classi derivate che ereditano da Veicolo. La classe Veicolo ha caratteristiche che sono condivise da tutti i tipi di veicolo (velocità, colore e marce, ad esempio). Le caratteristiche per ciascuno dei tipi di veicoli possono essere diverse. Ad esempio, un autocarro potrebbe avere la trazione integrale, ma un'auto no.

Esempio

L'esempio seguente mostra come una classe usa l'ereditarietà. La classe Automobile estende la classe Veicolo per ottenere l'altezza e la larghezza ma aggiunge anche la variabile numero di passeggeri.

class Vehicle
   {
	// Instance fields.
 		real height;
  		real width;
	// Constructor to initialize fields height and width.
	new(real _height, real _width)
   	{
    height = _height;
		  width = _width;
  	}
   }

class Car extends Vehicle
	{
	  // Additional instance field numberOfPassengers. Fields height and width are inherited.
 	  int numberOfPassengers;

	 // Constructor is overridden to initialize numberOfPassengers.
	 new(real _height, real _width, int _numberOfPassengers)
 	 {
	   // Initialize the fields.
	   super(_height, _width);
 	   numberOfPassengers = _numberOfPassengers;
 	 }
	}

Classi astratte

Le classi astratte sono identificate dalla parola chiave abstract. Non è possibile crearne un'istanza ma richiedono una sottoclasse ereditata dalla classe astratta. Le classi astratte vengono usate per implementare un concetto che verrà poi completato dalla sottoclasse. I metodi astratti possono essere dichiarati anche nelle classi astratte. I metodi astratti non consentono codice o dichiarazioni nel metodo. Una sottoclasse deve estendere la classe astratta per usare il metodo astratto.

Esempio

Di seguito è riportato un esempio di classe astratta. La classe Automobile estende la classe astratta Veicolo. Ciò consente alla classe Automobile di sostituire il metodo printInfo() e permette di aggiungere funzionalità al metodo operate() che non era incluso nella classe astratta.

abstract class Vehicle
{
      str owner;
      int age;

	void printInfo()
      {
    	Info(strfmt("%1, %2",owner, age));
      }
    abstract void operate()
    {
    }
 }

class Car extends Vehicle
{
     str model;
     void printInfo()
     {
            // overriding default functionality
            Info(strfmt("%1, %2, %3",owner, age, model));
     }
   void operate()
   {
        Info('running');
   }
}