Versione delle 19:56, 26 ott 2024

Come già menzionato nella pagina "Gli Oggetti e le Classi", una Classe può essere derivata da un'altra Classe superiore, ereditandone le caratteristiche pubbliche e le funzionalità. Lo scopo di questa logica fa parte del concetto di oggetto (o classe), comune a tutti i linguaggi orientati agli oggetti.

Come anche in altri articoli, non voglio qui avviare una discussione sul concetto di Classe, ma in qualche modo cercherò di spiegare il funzionamento di alcune caratteristiche di Gambas, collegando questo ad alcuni riferimenti e concetti generali.

Una Classe, o Oggetto, può essere considerato in modo modo semplice, come una collezione di caratteristiche che ne contraddistinguono l'uso all'interno di un programma. Come per un variabile, una volta creata e istanziata ^{[nota 1]} a livello procedura, assume un contenuto e una forma in memoria reali, altrettanto viene fatto per una classe. Una classe può contenere vari tipi di elemento, da semplici variabili a funzioni complesse; ogni volta che l'oggetto viene creato, in realtà vengono creati in memoria tutti i suoi elementi (private e pubblici). Al programma, poi, verrà ritornato il puntamento (o riferimento) in memoria del nuovo oggetto. L'utilizzo di una variabile, o una funzione, che fa parte dell'Oggetto, può essere fatta tramite il puntamento al nome stesso della variabile/funzione, passando prima per il puntamento iniziale della Classe:

 DIM NuovaClasse AS Window       dichiarazione di una classe di tipo Window
 ...
 NuovaClasse = NEW Window()      creazione della classe in memoria
 ...
 NuovaClasse.Resize(x,y)         utilizzo di un metodo (o funzione) della nuova classe
 ...
 NuovaClasse.Caption = "Titolo"  utilizzo di una proprietà della nuova classe
 ...
 DIM NuovoPuntatore AS Window
 NuovoPuntatore = NuovaClasse    creazione di un nuovo puntatore a una classe esistente

La logica degli oggetti permette di definire una serie di caratteristiche distinte legate all'Oggetto stesso.

Se associamo questa logica al mondo reale, possiamo fare un semplice esempio: immaginiamo di descrivere una matita (o lapis), utilizzando una Classe chiamata Matita:

 ' Gambas class file
 '
 ' CLASS Matita
 .
 INHERITS Object                     derivazione dalla classe padre
 .
 PUBLIC LunghezzaMatita AS Integer   proprietà caratteristica dell'oggetto

Nota: E' da tener presente che in Gambas, tutti gli oggetti (o classi) derivano dalla classe base Object, mentre per gli oggetti di tipo grafico esiste la sotto classe specializzata Control (che deriva anch'essa da Object).

Ritornando all'esempio, abbiamo definito una classe Matita, derivata dalla classe base Object. Da quest'ultima ne riceve tutte le caratteristiche, tra qui quelle fondamentali di creazione e distruzione dell'oggetto stesso. Alla classe Matita abbiamo aggiunto, rispetto a Object, la proprietà LunghezzaMatita, che nel nostro semplice esempio definisce la particolarità del nuovo oggetto; in questo caso LunghezzaMatita ha lo scopo di definire, appunto, la dimensione della matita. In questo modo non abbiamo fatto altro che definire un oggetto specializzato, ma ancora non ha tutti i requisiti. Noi sappiamo che in realtà esistono matite di ogni genere e colore, per cui occorre definire una nuova definizione dell'oggetto Matita, in modo che corrisponda ad un oggetto reale. Supponiamo di voler creare una Matita che può assumere diversi colori:

 ' Gambas class file
 '
 ' CLASS MatitaColorata
 .
 INHERITS Matita                    derivazione dalla classe padre Matita
 .
 PUBLIC Colore AS Color             caratteristica del nuovo oggetto

In questo esempio abbiamo creato un nuovo oggetto MatitaColorata, derivandola dalla classe superiore Matita. Questa nuova classe eredita la proprietà pubblica LunghezzaMatita della Classe superiore, ma aggiunge un'ulteriore proprietà: Colore. La bellezza di questa logica è che non dobbiamo scrivere nuovamente il codice per creare la matita, perché il codice è già incluso nella classe superiore, e la classe figlia lo eredita in modo automatico. La nuova classe è diventata una classe specializzata della classe Matita.

Uno degli scopi fondamentali della logica a oggetti, è proprio quella di non dover scrivere più volte lo stesso codice, e un oggetto può essere riutilizzato più volte per situazioni diverse. In questo modo possiamo creare oggetti diversi, derivati da una stessa fonte, ma che hanno specializzazioni diverse. Diversamente da vecchie versioni di Gambas, in queste ultime release non sembra ci siano limiti nell'inerenza di Classi e Sottoclassi (in alcuni miei programmi ho usato fino a 20 sottoclassi...).

Ritornando alle parole chiave CREATE PRIVATE e CREATE STATIC, facciamo un esempio teorico, ipotizzando per un momento che la classe base Matita non può essere direttamente utilizzata, perché non equipaggiata delle necessarie caratteristiche di funzionalità di una vera matita (non sappiamo neppure se ha la punta...).
Vediamo cosa succede con le due coppie di parole chiavi.

CREATE PRIVATE

« Queste due parole chiave, inserite all'inizio del codice di una classe, indicano all'interprete Gambas che la classe non può essere istanziata.
  Questa modalità viene usata per la costruzione di classi, padri di altre classi. »
(Traduzione dalla pagina ufficiale di Gambas)

Dato che la classe base Matita non può essere utilizzata direttamente, diciamo a Gambas di bloccarla, e di renderla utile solo per la creazione di classi inferiori:

 ' Gambas class file
 '
 ' CLASS Matita
 .
 INHERITS Object                       derivazione dalla classe padre Object
 .
 CREATE PRIVATE                        definizione di classe non istanziabile
 .
 PUBLIC LunghezzaMatita AS Integer     caratteristica del nuovo oggetto

La frase CREATE PRIVATE informa l'interprete di Gambas, che la classe Matita non può essere né creata, né istanziata all'interno del programma. A questo punto, se vogliamo creare una vera matita, occorre creare un altro oggetto, che assume proprietà reali (es. il colore):

 ' Gambas class file
 '
 ' CLASS MatitaRossa
 .
 INHERITS Matita                       derivazione dalla classe padre Matita
 .
 PUBLIC READ Colore AS Color           proprietà caratteristica del nuovo oggetto
 .
 PUBLIC FUNCTION Colore_Read()         metodo per il ritorno del valore della proprietà di colore
   RETURN Color.Red                    valore ritornato
 END

La nuova classe MatitaRossa non altro che la classe base Matita, ma con una caratteristica particolare: è rossa. La nuova proprietà Colore (che è impostata in sola lettura), ritorna il valore costante Red, della classe base statica Color di Gambas.

CREATE STATIC

« Queste parole chiave, se poste da sole all'inizio di un file di classe, indicano all'interprete che, applicando simboli non statici al nome della classe, ne verrà creata al volo un'istanza nascosta automatica. »
(Traduzione dalla pagina ufficiale di Gambas)

La frase chiave CREATE STATIC, a differenza della precedente, dice all'interprete di Gambas che la classe in oggetto, oltre a non poter essere creata, e quindi istanziata, deve essere creata in memoria in modo automatico, e che deve essere accessibile già in fase di avvio programma. Questo vuol dire che, a differenza di una normale classe o di una classe privata (vedi precedente), la nuova classe è già disponibile e attiva, senza bisogno di istruzioni di creazione. Esempi, in Gambas, sono le classi Form e Settings, che sono direttamente utilizzabili, in pratica sono create automaticamente e al volo... ^{[nota 2]}

Come per CREATE PRIVATE, la sintassi deve trovarsi all'inizio del codice della classe, o subito dopo un'istruzione INHERITS.

 ' Gambas class file
 '
 ' CLASS Matita
 .
 CREATE STATIC                   definizione di classe statica

 ' Gambas class file
 '
 ' CLASS MatitaRossa
 .
 INHERITS Matita
 .
 CREATE STATIC                   definizione di sotto classe statica

A differenza dell'esempio fatto per CREATE PRIVATE, la nuova classe MatitaRossa assume sì le proprietà della classe superiore Matita, ma non c'è bisono di crearla, perché lo fa in automatico l'interprete di Gambas all'avio del programma, e la classe è immediatamente disponibile per l'uso.

E' ovvio che, in questo caso, non è possibile avere a disposizione, e quindi creare, multiple istanze dello stesso oggetto, per cui questo tipo di approccio ha l'obiettivo basilare di: mantenere una gestione del programma a oggetti, e l'utilizzo di una classe statica come una sorta di contenitore di funzionalità specifiche, un po' come poi è il modulo in Gambas.

Note

[1] Quando una Classe viene " istanziata ", viene creato un Oggetto di quella Classe.
L'Oggetto di una Classe è l'elemento del codice, con il quale sfruttare concretamente le funzionalità (Proprietà, Metodi ed Eventi) della Classe, alla quale esso appartiene e fa riferimento.

[2] A una Classe statica si può accedere senza bisogno di creare un'istanza (Oggetto) della Classe.