Pascal/Concetti fondamentali

La programmazione orientata agli oggetti gra attorno a tre concetti fondamentali e di cruciale importanza. Questi concetti sono:

• L'incapsulamento
• L'ereditarietà
• Il polimorfismo

L'incapsulamento

Per un buon approccio alla programmazione agli oggetti, la prima cosa che si deve fare è stabilire quali sono gli oggetti, cosa fanno, quali sono le loro caratteristiche e come interagiscono fra di loro.

Abbiamo detto che gli oggetti sono strutture che contengono campi e metodi. Per campi si intende variabili (in senso molto lato) o meglio, puntatori a zone di memoria. I metodi invece sono le procedure, le funzioni, i costruttori e i distruttori (concetti che vedremo più avanti). Quindi i metodi sono la parte attiva di un oggetto, che possono modificare le caratteristiche di questo oggetto, cioè possono modificare i campi. Il procedimento con la quale si incapsulano i metodi e i campi in un oggetto, si chiama incapsulamento. Per essere più precisi, a venire incapsulata è la classe, che sarebbe un "tipo" di oggetto. Sebbene nella sintassi del Turbo Pascal venga utilizzata la parola chiave object per definire una classe, ciò non deve creare perplessità. Un oggetto per essere creato ha bisogno di essere istanziato da una classe, quindi per esempio avendo una classe Studente, da questa classe possono venire istanziati due oggetti: Francesco e Giorgio.

Qui di seguito un esempio in codice su come creare un oggetto (classe):

TYPE TStudente = OBJECT
                    Nome,Cognome: String;
                    AnnoDiNascita: integer;
                    FUNCTION GetNome : String;
                    FUNCTION GetCognome : String;
                    FUNCTION GetAnnoNascita : integer;
                    PROCEDURE SetNome(nome:string);
                    PROCEDURE SetCognome(cognome:string);
                    PROCEDURE SetAnnoNascita(anno:integer); 
                 END;

In questo modo abbiamo definito la classe TStudente che contiene i campi Nome, Cognome e AnnoDiNascita, e i metodi per memorizzare i dati o per ottenerli dall'esterno.

L'ereditarietà

La programmazione orientata agli oggetti utilizza per gli oggetti una gerarchia ben definita che si rivela molto utile e produttiva ai fini della scrittura del programma. Questa gerarchia si può rappresentare esattamente come un albero genealogico. I benefici portati da questa pratica sono vari.

Immaginiamo un programma che faccia largo uso delle finestre, quindi creiamo una classe che descrive i vari comportamenti di una finestra: la riduzione a icona, lo spostamento, l'ingrandimento ecc. Noi sappiamo dall'uso del computer che non c'è solamente un tipo di finestra: ci sono le MessageBox, le finestre di dialogo, le finestre di editing, ecc. quindi dovremmo creare una classe per ogni tipo di finestra e ridefinire i vari comportamenti per ogni tipo di finestra; ma se invece creaiamo una classe per ogni finestra che eredita da una classe principale di una finestra generica, eviteremo di definire i comportamenti principali per ogni finestra.

Quindi un oggetto2 che eredita da oggetto1 potrà usufruire di tutti i suoi campi e metodi.

Da qui appare chiaro il perchè usare l'ereditarietà. Ecco un esempio in codice:

TYPE TBox1 = OBJECT
                Altezza, Lunghezza, Larghezza: integer;
                PROCEDURE Disegna;
                PROCEDURE Imposta(alt, lung, larg: integer);
             END;
     TBox2 = OBJECT (TBox1)   {TBox2 eredita TBox1}
                PROCEDURE ApriScatola;
                PROCEDURE ChiudiScatola;
             END;

Il polimorfismo

Il polimorfismo è un concetto un po' più avanzato dei precedenti, ma comunque importantissimo. Polimorfismo vuol dire "molte forme", e diciamo subito che si riferisce a una procedura o una funzione. Facciamo subito un esempio: supponiamo di voler creare un programma per disegnare delle figure piane (tringoli, rettangoli, circonferenze ecc.). Per prima cosa creiamo un oggetto comune, per esempio figurabidimensionale, e supponiamo che contenga una procedura di nome Disegna. La dichiareremo virtual, ovvero non la definiamo nell'oggetto figurabidimensionale, ma la definiamo negli oggetti che ereditano questo. Comunque i metodi virtuali sono un concetto che esporremo più avanti.

Da questo oggetto erediatiamo altri oggetti di nome triangolo, rettangolo, circonferenza, e definiamo il metodo Disegna per ogni oggetto (che ovviamente avrà una diversa implementazione per ciascuno).

Adesso, supponiamo che una procedura più avaanti si serva del metodo draw, ma non specifica quale oggetto stiamo utilizzando. Per esempio:

PROCEDURE UnaProcedura(figura:figurabidimensionale);
BEGIN
   ...
   ... 
   ...
   figura.Draw;
   ...
   ...
   ...
END;

In questo esempio il metodo Draw non sarà quello di figurabidimensionale, ma quello della classe figlia che eredita, anche perchè in figurabidimensionale il metodo non è definito.

Questa pratica è chiamata polimorfismo.