Classe astratta

Da Wikipedia, l'enciclopedia libera.

Questa voce di informatica è solo un abbozzo: contribuisci a migliorarla secondo le convenzioni di Wikipedia.

In informatica si dice classe astratta una classe che definisce una interfaccia senza implementarla completamente. Ciò serve come base di partenza per generare una o più classi specializzate aventi tutte la stessa interfaccia di base. Queste potranno poi essere utilizzate indifferentemente da applicazioni che conoscono l'interfaccia base della classe astratta, senza sapere niente delle specializzate.

[modifica] Caratteristiche

La classe astratta da sola non può essere istanziata, viene progettata soltanto per svolgere la funzione di classe base (chiamata a volte anche classe genitrice) e da cui le classi derivate (chiamate anche classi figlie) possono ereditare. Le classi astratte sono usate anche per rappresentare concetti ed entità astratte. Le caratteristiche "incomplete" della classe astratta vengono condivise da un gruppo di sotto-classi figlie, che vi aggiungono caratteristiche diverse, in modo da colmare le "lacune" della classe base astratta.

Le classi astratte possono essere considerate come super-classi che contengono metodi astratti, progettate in modo che le sotto-classi che ereditano da esse ne "estenderanno" le funzionalità implementandone i metodi. Il comportamento definito da queste classi è "generico" e la maggior parte dei costrutti della classe sono indefiniti e non implementati. Prima che una classe derivata da una classe astratta possa essere istanziata essa ne deve implementare tutti i metodi astratti.

Una classe qualsiasi, che abbia almeno un metodo definito abstract e quindi non implementato, diventa a sua volta astratta. E' necessario quindi dichiarare tale classe come astratta per evitare un errore a tempo di compilazione.

Riassumendo: quando definisce una classe astratta il programmatore deve tener presente che si tratta di una classe che non può essere istanziata direttamente. Per fare ciò è necessario creare una classe derivata mediante l'ereditarietà. Questo processo di astrazione ha lo scopo di creare una struttura base che semplifica il processo di sviluppo del software.

Al contrario, invece, una classe concreta è una classe su cui possono essere create ("istanziate") entità chiamate "oggetti".

La maggior parte dei linguaggi di programmazione orientati agli oggetti consente al programmatore di specificare, con apposite parole chiave, quali classi sono astratte, impedendo in modo automatico che su di esse vengano istanziati oggetti (ad esempio Java usa la keyword abstract). Con questi accorgimenti il programmatore può concentrarsi sull'analisi e lo sviluppo del programma: l'implementazione effettiva delle funzionalità necessarie viene fatta nelle classi derivate che ereditano da quella astratta.

[modifica] C++

In C++ una classe astratta deve contenere almeno una funzione virtuale pura. Se si cerca di istanziarla viene generato un errore.

virtual bool draw () const = 0

è una funzione virtuale pura e la classe che la contiene diventa astratta.

[modifica] Java

In Java una classe astratta si crea in questo modo:

abstract class Pippo {
    public Pippo(...argomenti...){
        // costruttore
    }

    public void foobar() {
        // un metodo banale
    }
}

I costruttori vanno necessariamente implementati nelle classi figlie. tramite la parola riservata extends si crea una classe figlia:

class Pluto extends Pippo {
    public Pluto(...argomenti...){
        super(...argomenti...); // richiama il costruttore della super-classe
        // eventuale codice aggiuntivo
    }

    public void foobar() { // estensione (facoltativa) del metodo foobar()
        // eventuale codice...
        super.foobar(); // facoltativo: richiama il metodo foobar della super-classe
        // eventuale codice...
    }

}