Java: il modificatore abstract (e le classi astratte)

Il modificatore abstract diciamo che è l’antitesi del modificatore final. Abstract può essere applicato sia a metodi che alle classi, ma non a variabili in quanto dichiarare una variabile astratta non avrebbe nessun senso logico. Iniziamo con il dire che se vogliamo definire un metodo astratto, dobbiamo variare la sintassi per la scrittura di tale metodo in quanto dovremo eliminare le parentesi graffe. Un metodo astratto si definisce nel seguente modo:

public abstract tipoDiRitorno nomeMetodo();

Quindi come possiamo vedere un metodo astratto non implementa nessun pezzo di codice, ma si limita ad essere una sorta di definizione.

Se all’interno di una classe dichiariamo un metodo astratto, anche la classe dovrà essere definita come tale. Una classe, se definita astratta, non può essere in alcun modo istanziata e ciò è coerente con la definizione di oggetto in quanto un oggetto è una realizzazione concreta di una classe, ma ciò non è possibile se la classe è astratta. Ovviamente, se la classe non può essere istanziata, non sarà nemmeno possibile richiamare uno dei suoi metodi astratti, ma sarà possibile utilizzare l’override dei metodi nelle sotto classi che derivano dalla classe astratta. Arrivati a questo punto, la domanda che ognuno si porrà è la seguente: ma a cosa servono queste classi astratte dato che non possono essere istanziate? Vediamolo con un esempio: immaginiamo di avere una classe "Programmatore" e di avere un metodo astratto che definisce come il programmatore programmi una certa applicazione. Avremo dunque:

public abstract class Programmatore {
  public abstract void programma();
}

Necessariamente dobbiamo definire la classe "Programmatore" come astratta in quanto il metodo "programma()" sarà per forza un metodo astratto. Infatti il metodo citato modella l’approccio alla programmazione che ha quel programmatore a seconda del linguaggio che utilizza: se un programmatore usa il C avrà un approccio procedurale alla programmazione, se il programmatore usa il Java l’approccio sarà orientato agli oggetti e dunque il metodo "programma()" assume due significati diversi. Dunque nelle sottoclassi "ProgrammatoreC" e "ProgrammatoreJava" effettueremo l’override del metodo "programma()" adattandolo ai due concetti di programmazione. Quindi la classe astratta è un costrutto che ci permette di definire una generalizzazione di un certo concetto e impone che le sottoclassi relative alla generalizzazione effettuino l’override sui metodi per adattare il metodo astratto alle caratteristica della sottoclasse rendendolo così utilizzabile dall’istanza della sottoclasse.

A questo punto verrebbe da pensare che nelle classi astratte, utilizzate come definizioni di gruppi di oggetti, dato che non possono essere istanziate non debbono contenere un costruttore. Ciò è errato in quanto, quando abbiamo parlato dei costruttori, abbiamo detto che al momento della creazione di un oggetto automaticamente viene richiamo il costruttore della superclasse a cui fa riferimento. Dunque quando istanzieremo una classe derivata da una classe astratta andremo sempre e comunque ad invocare il costruttore di quella classe, che nel nostro caso della classe Programmatore è il costruttore di dafault. Dunque dato che una classe astratta può contenere anche attributi e un relativo costruttore, è bene inserire all’interno della classe astratta anche gli attributi generali che avranno le classi derivate. Per capirsi, la classe "Programmatore" potrà essere riscritta in questo modo:

public abstract class Programmatore {

  private String nome;
  private String cognome;
  private int anniEsperienza;
    
  public Programmatore(String n, String c, int a){
    nome=n;
    cognome=g;
    anniEsperienza=a;
  }

  public abstract void programma();
}

A questo punto quando estenderemo la classe astratta per esempio creando la classe "ProgrammatoreJava" richiameremo all’interno del costruttore il reference super() passandogli i tre valori relativi a nome, cognome e agli anni di esperienza nella programmazione.