Differenze tra le versioni di "Metodi nascosti"

Versione delle 18:45, 21 mar 2017

_new(), _free()

In Gambas, per tutti gli oggetti base, sono presenti alcuni metodi, che di norma non vengono presi in considerazione e che, in effetti, non vengono neppure dichiarati durante la costruzione di un oggetto. Dato che ogni oggetto deriva in ogni caso dalla classe base Object di Gambas, anche queste proprietà nascoste vengono definite nelle nuove sotto classi. L'utilità di questi metodi è enorme, dato che tramite queste è possibile modificare le proprietà di base dell'oggetto stesso, passare parametri, definire condizioni di funzionamento, chiudere file aperti, rilasciare risorse, ecc. Questa particolarità è inclusa sia nelle classi dinamiche (es. ListBox, Menu, ecc.), sia le classi statiche come, ad esempio, le Form.

In genere, nei linguaggi odierni, questo tipo di implementazione, oltre che far parte del concetto stesso di oggetto (o classe), ha una funzione e una visibilità più evidente, come ad esempio il C++, Java e Il Python (per citarne alcuni). Nella maggioranza dei casi, questi metodi diventano quasi indispensabili per il funzionamento di un'applicazione.

Per ritornare a Gambas, parliamo dei due metodi che, a mio avviso, credo siano le funzioni più utili: _new() e _free().

_new() - Il Costruttore

Per fare un esempio, la classe Form non accetta di norma alcun parametro, ma vediamo come è possibile modificare questa impostazione in modo tale, ad esempio, da potergli passare un array di stringhe:

Creiamo una Form, e apriamo l'editor di testo per modificare il codice della Form, e scriviamo le istruzioni seguenti:

 PRIVATE $arr AS String[]
 ...
 ...
 PUBLIC SUB _new( arr AS String[] )
   ...
   $arr = arr
   ...  
 END

Cosa abbiamo ottenuto? Bè, nulla di particolare... abbiamo solo detto a Gambas che la Form ora accetta un parametro, di tipo String[] !

Questa possibilità è solo permessa attraverso questo metodo nascosto, altrimenti la cosa non sarebbe stata fattibile, se non attraverso metodi poco ortodossi (come, ad esempio, delle variabili globali), e questo permette di condizionare enormemente un oggetto. Se, come da esempio, salviamo il parametro in una variabile privata della classe (nell'esempio: $arr), possiamo poi gestire i suoi dati all'interno della classe, modificarli e, magari restituirli alla chiusura della Form. Un'altra ottima caratteristica di questo metodo, è il fatto che il suddetto viene sempre e comunque invocato alla creazione della classe, prima di qualunque altro, per cui rende possibile condizionare totalmente la gestione della classe stessa; nessun evento e nessun'altra funzione sarà chiamata o attivata, se non dopo l'esecuzione del metodo _new() (il Costruttore!).

Non esistono limitazioni sulla posizione del metodo all'interno del codice ma, se presente verrà invocato.

L'unica cosa da tener presente è che, data l'inerenza dalla classe base Object, e da eventuali altre, verranno chiamati prima i metodi _new() delle classi superiori, partendo da quella più in alto, fino ad arrivare alla nostra (come per l'esempio). Eventuali parametri, già previsti nelle classi superiori, verranno caricati prima di quelli della nostra classe. E' anche da ricordare che l'elenco dei parametri passati alla nostra classe deve comprendere anche quelli delle classi superiori, e il loro posizionamento deve seguire la logica: da destra verso sinistra, ovvero la prima che sarà letta e utilizzata è la prima a destra.

Come esempio, costruiamo una classe MyButton, derivata dalla classe base Button di Gambas.

Tramite l'IDE di Gambas, creiamo una classe MyButton, quindi apriamo l'editor per modificarne il codice:

 INHERITS Button
 ...
 PUBLIC SUB _new( etichetta AS String )  'passiamo l'etichetta che verrà impostata come testo del pulsante
   ...
   WITH ME
     .Text = etichetta
   END WITH
   ...
 END

A questo punto, per utilizzare l'oggetto MyButton, è necessario il codice seguente:

 PUBLIC SUB CreaMyButton()
   ...
   DIM MyBtn AS MyButton
   ...
   MyBtn = NEW MyButton("OK", hForm)
   ...
 END

Come è possibile capire dall'esempio, nella funzione "CreaMyButton()", viene definito un oggetto MyBtn di tipo MyButton (la nostra classe), e nella sua creazione vengono passati due parametri: la stringa "OK" e hForm. Il primo rappresenta l'etichetta da stampare sul pulsante, il secondo il riferimento all'oggetto contenitore (una Form). E' da notare la posizione dei due parametri, in cui nel primo posto viene passata l'etichetta, nel secondo il riferimento al contenitore; nella creazione della classe MyButton, come prima cosa viene creata la classe base Button, a cui verrà passato il riferimento alla Form (il secondo parametro), quindi verrà creata la classe derivata MyButton, a cui verrà passata l'etichetta che abbiamo definito come parametro nel metodo _new() (primo parametro).

Con questa logica è anche possibile definire parametri opzionali (OPTIONAL), magari con valori di default che verranno impostati se non presenti nella creazione dell'oggetto:

Esempio:

 INHERITS Button
 ...
 PUBLIC SUB _new( OPTIONAL etichetta AS String = "OK" )  'se non passata, l'etichetta sarà impostata a "OK"
   ...
   WITH ME
     .Text = etichetta
   END WITH
   ...
 END

_free() - Il Distruttore

Come esiste un Costruttore, credo a mio avviso debba esistere un Distruttore, a completamento del filo logico. In Effetti, come anche in altri linguaggi, questo "Distruttore" esiste, e in Gambas è assunto dal metodo "_free()".

Il metodo _free() ha il non semplice compito, almeno per quanto riguarda le operazioni a basso livello, di chiudere e rilasciare le risorse occupate e utilizzate dalla classe. In definitiva è un pulitore.

Il motore di Gambas ha una sua logica interna, che provvede automaticamente questo tipo di pulizia, che avviene normalmente per gli oggetti grafici, come ad esempio le Form e gli oggetti che racchiudono; ma, in alcuni casi, è necessario provvedere manualmente (inteso come codice) a liberare le risorse utilizzate. Questo è il caso, per esempio, di file aperti nella classe, di link a oggetti esterni alla classe, e così via. In questi casi, l'oggetto, non essendo in effetti consapevole degli elementi inseriti, al di fuori degli elementi previsti (esempio precedente, oggetti grafici), non prevede di gestirne la loro eliminazione, oltre al fatto che questa non è dipendente da situazioni o logiche previste nella loro impostazione di base. Per questi motivi, viene d'aiuto il metodo "_free()" che, come per "_new()", viene chiamato sempre e comunque, ma solo quando l'oggetto (o la classe) viene distrutta ed eliminata. Il metodo _free() non prevede parametri, nè li accetta, perchè la sua esecuzione è automatica e non può essere alterata da programma. Al suo interno, però, è possibile eseguire tutte le operazioni e il codice necessario alla corretta chiusura dell'oggetto. Credo sia inutile fare esempi, dato che comunque il codice non dipenderebbe dall'oggetto, ma sarebbe solo codice esterno ad esso; l'unico esempio è quello della dichiarazione del metodo stesso:

 PUBLIC SUB _free()
   ...
   'codice libero
   ...  
 END

Il Distruttore è solo un Metodo nascosto che viene eseguito al momento della distruzione dell'Oggetto, di solito viene usato per liberare la memoria allocata dalla Classe (ma non la memoria della Classe !). Più in particolare il Distruttore non l'Oggetto stesso (che viene cancellato dal Metodo ".Delete", quale risorsa dell'Oggetto medesimo), ma la memoria allocata dai Metodi dell'Oggetto.