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 definisce classe astratta una classe che 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, ma che, da sola, non può essere istanziata. 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.

Riassumendo: quando definisce una classe astratta il programmatore deve tener presente che si tratta di una classe composta da elementi che devono essere implementati successivamente 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...
    }

}