Classi ed Oggetti: i metodi

Metodi

Abbiamo visto in precedenza cosa è e come viene definito un metodo. Ora vediamo di approfondire l’argomento. In Object Pascal ci sono due parole chiave che rientrano nella creazione ed utilizzo dei metodi; queste sono Inherited e Self.

Inherited permette di richiamare i metodi dell’antenato da cui deriva la classe a cui appartiene il nuovo metodo. Per meglio dire, se la classe da cui abbiamo ereditato definisce un metodo MioMetodo scrivendo il codice seguente richiamo quel metodo

Procedure MiaClasse.MioMetodo(Valore : Integer);

Begin

Inherited;

End;

Ciò permette di aggiungere funzionalità al metodo di base ereditato.

Non specificando nessun identificatore dopo la parola riservata Inherited, questa farà riferimento al metodo dell’antenato avente lo stesso nome del metodo in cui si trova la parola chiave Inherited. Se dopo di essa non viene specificato alcun parametro, verranno passati al metodo ereditato gli stessi parametri passati al metodo della classe che si sta definendo.

Se invece la parola Inherited è seguita da un identificatore di metodo, questa effettuerà una chiamata al metodo corrispondente all’identificatore indicato ricercandolo a partire dall’antenato immediato.

La parola chiave Self permette di fare riferimento, all’interno dell’implementazione di un metodo, all’oggetto dal quale il metodo viene chiamato.

Collegamento dei metodi

I metodi possono essere di tre tipi: statici, virtuali, dinamici. Quando un metodo viene definito, per impostazione predefinita è statico.

Nella chiamata di un metodo statico, l’implementazione da attivare viene determinata in base al tipo, dichiarato in fase di compilazione, della classe che viene utilizzata per la chiamata del metodo.

Quindi per esempio, avendo le dichiarazioni di classi seguenti

Type TClasse1 = Class

Procedure Metodo1;

End;

TClasse2 = Class(TClasse1)

Procedure Metodo1;

End;

ed eseguendo il seguente codice

Var Classe1 : TClasse1;

Classe2 : TClasse2;

Begin

Classe1 := TClasse1.Create;

Classe1.Metodo1;
//L’implementazione utilizzata è quelle di TClasse1

Classe1.Destroy;

Classe1 := TClasse2.Create;

Classe1.Metodo1;
//L’implementazione utilizzata è quelle di TClasse1

TClasse2(Classe1).Metodo1;

Classe1.Destroy;

Classe2 := TClasse2.Create;
//L’implementazione utilizzata è quelle di TClasse2

Classe2.Metodo1;

Classe2.Destroy;

End;

avremo che l’esecuzione della seconda chiamata “Classe1.Metodo1” determinerà l’esecuzione dell’implementazione del metodo nella classe “TClasse1” anche se la variabile “Classe1” fa riferimento ad un oggetto di tipo “TClasse2”.

I metodi dichiarati virtual o dynamic possono essere ridefiniti nelle classi discendenti. Per dichiarare dei metodi come virtual o dynamic occorre specificare dopo la loro dichiarazione le parole chiave virtual o dynamic. A differenza dei metodi static la determinazione dell’implementazione del metodo da utilizzare nella chiamata viene determinata in base al tipo run-time. Per ridefinire un metodo virtual o dynamic occorre specificare, nella classe discendente, un metodo con lo stesso nome del metodo della classe antenato e utilizzare la parola chiave override dopo la sua dichiarazione.

Apportando le modifiche del caso, riprendiamo l’esempio visto in precedenza per i tipi static e vediamo le differenze

Type TClasse1 = Class

Procedure Metodo1;

End;

TClasse2 = Class(TClasse1)

Procedure Metodo1; override;

End;

Var Classe1 : TClasse1;

Classe2 : TClasse2;

Begin

Classe1 := TClasse1.Create;

Classe1.Metodo1;
//L’implementazione utilizzata è quelle di TClasse1

Classe1.Destroy;

Classe1 := TClasse2.Create;

Classe1.Metodo1;
//L’implementazione utilizzata è quelle di TClasse2

TClasse2(Classe1).Metodo1;

Classe1.Destroy;

Classe2 := TClasse2.Create;

Classe2.Metodo1;
//L’implementazione utilizzata è quelle di TClasse2

Classe2.Destroy;

End;

Come ripostato nel commento del codice, la seconda chiamata a “Classe1.Metodo1” utilizzerà l’implementazione di “TClasse2” poichè il tipo run-time al momento della chiamata è “TClasse2”.

Le differenze tra metodi virtuali e dinamici consiste essenzialmente nell’implementazione dellq chiamata al metodo in fase di esecuzione. I metodi viruali sono ottimizzati per velocità, mentre i metodi dinamici per dimensione.

Un’altro tipo interessante di metodo e quello dei metodi astratti. I metodi astratti permettono di definire metodi senza alcuna implementazione del metodo stesso. Ciò risulta utilie quando si vogliono creare delle classi base che stabiliscano l’interfaccia base dei metodi ma che permettano alle classi discendenti di definire l’implementazione di quei metodi. Questo tipo di metodo è un particolare tipo di metodo astratto o dinamico.

Per dichiarare un metoto astratto, occorre specificare dopo le parole chiave virtual o dynamic la praola chiave abstract.

Altri due tipi di metodi importanti nella programmazione ad oggetti sono i metodi costruttori e distruttori. Questi si occupano, come dicono le parole stesse, di creare ed inizializzare un’istanza di classe o di distruggere e liberare la memoria occupata dall’istanza di classe precedentemente creata.

I metodi costruttori sono caratterizzati dalla parola chiave constructor al posto della parola chiave procedure o function. L’implementazione di questi metodi, prevede la creazione dell’istanza di classe allocando memoria nello heap, ed l’inizializzazione automatica a zero dei valori ordinal, a nil dei campi puntatore e classe, l’azzeramento di tutti i campi string. Solitamente all’interno di un metodo costruttore viene prima di tutto chiamato il metodo costruttore ereditato dall’antenato per inizializzare il codice comune, dopo di che viene eseguito il codice necessario ad inizializzare il codice specificao per la classe discendente. Potrebbe capitare che durante l’esecuzione del codice di inizializzazione si generino delle eccezioni; in tal caso verrà eseguito automaticamente il distruttore destroy per disturggere l’oggetto non completato. Nella creazione di un oggetto, occorre chiamare il metodo costruttore facendolo precedere dal nome della classe di appartenenza dell’oggetto che si vuole creare. In tal modo, il metodo costruttore restituirà, al termine della chiamata, un puntatore all’istanza appena creata. Se il metodo costruttore viene chiamato utilizzando un riferimento ad un oggetto, questo non restituisce nulla.

I metodi distruttori seguono le stessa regola dichiarativa dei metodi costruttori tranne per il fatto che utilizzano la parola chiave destructor al posto di constructor. I metodi distruttori si occupano di distruggere l’oggetto e deallocare la memoria da esso occupata. Per chiamare un metodo distruttore bisogna fare riferimento ad un oggetto istanza come per esempio

MioOggetto.Destroy;

La chiamata al metodo destroy produce l’immediata esecuzione del codice contenuto nell’implementazione del metodo destroy stesso. All’interno del metodo distruttore viene eseguito tutto quel codice atto ad eliminare eventuali altre istanze di oggetti incorporati e nella liberazione della memoria da loro occupata. L’ultima istruzione di un metodo destroy , è solitamente una chiamata al metodo destroy ereditato in maniera da eliminare i campi e ripulire la memoria occupata dal codice ereditato. Come detto in precedenza, se durante la creazione di un oggetto viene sollevata una eccezione, viene eseguito il metodo destroy. In tal caso, questo metodo deve essere pronto ad interagire con codice non completamente inizializzato che, in particolare per i campi di tipo class, significa controllare se il cmapo ha valore Nil prima di effettuare la chiamata al metodo destroy della classe di quel campo. Per questo Delphi mette a disposizione il metodo Free definito nella classe TObject che permette di gestire in automatico il controllo sulla presenza di valori Nil prima di eseguire la distruzione dell’oggetto.

Gestori di messaggi

Un altro tipo di metodo messo a disposizione in Delphi è il gestore di messaggi. Un gestore di messaggi sono metodi che rispondono ai messaggi inviati da Windows, da altre applicazioni o dall’applicazione che stiamo realizzando. Esistino messaggi predefiniti e messaggi che possono essere dichiarati dallo sviluppatore.

Per dichiarare un gestore di messaggi, si include la direttiva message dopo la dichiarazione del metodo seguito da un identificatore integer costante di messaggio il cui valore deve essere compreso tra 1 e 49151. Alcuni dei messaggi utilizzati da Windows e quelli utilizzati dai controlli della VCL sono definiti nella unit messages. Nella definizione di ogni messaggio è necessario dichiarare una costante contenente l’ID del messaggio ed una struttura (un record) che descriva il contenuto del messaggio. Ecco la dichiarazione di un gestore di messaggio er il messaggio WM_CHAR

Type TTextBox = Class(TCustomControl)

Private

Procedure WMChar(Var Message : TWMChar); message
WM_CHAR;

…

End;

Il codice seguente, ripreso dal manuale del linguaggio, mostra come implementare il gestore di evento dichiarato in precedenza affinchè venga eseguito un codice particolare alla pressione del tasto invio in un controllo di tipo TTextBox e l’esecuzione del codice ereditato per tutti gli altri tasti

Procedure TTextBox.WMChar(Var Message : TWMChar);

Begin

If Chr(Message.ChrCode) = #13 then

ProcessEnter

Else

Inherited;

End;

tramite l’istruzione Inherited viene ricercato nelle classi antenato una implementazione del gestore per quel messaggio e qualora non ne sia disponibile una, viene eseguito il metodo gestore predefinito DeafultHandler definito nella classe TObject. Per richiamare un gestore di messaggio, si utilizza il metodo Dispatch dichiarato nella classe TObject. Questo metodo richiede che gli venga passato un record il cui primo campo sia di tipo cardinal e contenga l’ID del messaggio.