Lezioni: programmazione Orientata agli Oggetti

L'intero codice, pensato e redatto dal programmatore, è finalizzato ad un concreto risultato: è scritto per fare ed ottenere qualcosa.
Le funzioni, espresse dai comandi, operano su dati matematicamente rilevanti, appositamente memorizzati anche ai fini di un loro uso temporalmente differenziato.

Scopo ultimo e scopi intermedi di un programma

Non esiste soltanto lo scopo del programma, ciò per cui fu pensato e scritto, ma anche quello delle singole parti del codice: alcune sue parti infatti tendono necessariamente a specifici e limitati scopi, funzioni che, coordinate e gestite in una visione e logica più ampia (quella appunto dell'intero programma), realizzano il fine ultimo per il quale il programma fu pensato e scritto. Lo svolgimento del programma ed il conseguente perseguimento del fine o dei fini ultimi previsti sono conseguiti attraverso l'adozione di risorse fra loro logicamente e funzionalmente coerenti e connesse.
Nella stesura e nell'esecuzione del programma subentrano una serie di risorse, costituite da dati che rappresentano la materia manipolata dalle funzioni, e sulla quale queste si cimentano esplicando le loro capacità.

La "Programmazione Orientata agli Oggetti" (POO) presuppone nello sviluppo e nell'esecuzione dei programmi una dialettica di entità che esprimono loro peculiari proprietà e funzionalità tese al raggiungimento di un concreto risultato, utile nell'economia più ampia del programma realizzato.
Nella POO la pluralità di risorse utili per il raggiungimento di un determinato risultato funzionale al programma è un servizio complessivo offerto da una specifica entità. Tutti gli attributi e funzioni di tale entità di programmazione rappresenta il servizio, che tale entità può offrire al programmatore, ed è finalizzata allo sviluppo ed al raggiungimento di specifici scopi.
L'allocazione di memoria diviene pertanto funzionale al raggiungimento di questo servizio.

La Classe e gli Oggetti

L'entità informatica che assume in sé determinate risorse, funzionali ed utili al raggiungimento di uno scopo nel codice del programma, è una definizione generale di tali proprietà e funzioni. Essa è innanzitutto un corpus unico formato da attributi e funzionalità specifiche e coerenti potenzialmente attivabili e fruibili.
Essa non può essere direttamente invocata nel codice del programma per attuare ed utilizzare le sue risorse: v'è bisogno di porre in essere proprie istanze specifiche.
Le caratteristiche definite e dichiarate da un'istanza astratta possono essere comuni a più entità concrete, che condividono pertanto quelle risorse, ed escludono altre che o non posseggono quelle caratteristiche o le posseggono solo in parte.
Poiché le istanze specifiche, accomunate dal possesso di medesime risorse, si riconoscono quali parti di una determinata entità astratta, esse sono elementi individuali di un Insieme che le raccoglie logicamente. Tale Insieme rappresenta una Classe di una o più istanze particolari che, possedendo tutte le risorse tipiche di quella Classe, consentono alla Classe medesima di attuare le sue potenzialità ed al programmatore di utilizzare proficuamente quelle risorse dichiarate solo in astratto dalla Classe.

La Classe è dunque un'entità che si pone in una dimensione universale. E', come già detto, un Insieme che raccoglie e dà significato ad entità particolari, contingenti ad essa sottoposte e riferentesi: gli Oggetti.
Gli Oggetti sono insomma quelle entità particolari, di cui si è parlato in principio, ma la Classe sia concettualmente che informaticamente in POO viene prima dell'Oggetto: essa è il presupposto dell'esistenza dell'Oggetto (ossia della variabile del tipo di quella Classe).
La Classe è la "definizione" di una realtà, ed anzi una realtà che "definisce" e "raggruppa" delle caratteristiche specifiche (si pensi ad esempio alla Classe "Button"); l'Oggetto è la realtà che il programmatore crea nel codice per utilizzare le risorse della Classe. In tal senso la Classe "raggruppa" anche gli eventuali Oggetti che, creati, ad essa si riferiscono.
La Classe pre-esiste all'Oggetto, essendo possibile avere comunque una Classe, ma è possibile evitare di creare l'Oggetto mediante "New". Una Classe può esistere pur non esistendo un suo Oggetto, un suo esemplare concreto utilizzabile nel codice. Invece non esiste un Oggetto che non si riferisca ad una qualche Classe. Infatti, quando esso viene creato, viene sempre riferito ad "una" specifica "Classe".

La conoscenza delle caratteristiche specifiche di una Classe consente di conoscere le proprietà e le funzionalità, ossia le risorse, di ogni Oggetto appartenente a quella determinata Classe.

Gli Oggetti sono entità, elementi della POO che si riferiscono e rimandano ad una realtà astratta, paradigmatica, ad un modello di proprietà e funzionalità.
Gli Oggetti sono realtà creabili e distruttibili, e per questo contingenti, che permettono l'effettivo e concreto utilizzo all'interno del codice di un programma delle caratteristiche, degli attributi e delle funzionalità di una Classe. Mentre la Classe esprime come mera possibilità alcune capacità e/o attributi, gli Oggetti di tali Classi mettono in atto, fattivamente, le capacità delle Classi. Se la Classe è un'entità che esprime "in potenza" le sue funzionalità e proprietà che dichiara, gli Oggetti rappresentano "in atto" tali caratteristiche. La Classe dichiara in astratto ciò che l'Oggetto pone in atto ed esprime in concreto nel codice del programma.
Una Classe in quanto Modello non esiste nel/sul mondo, ossia concretamente, è semplicemente un predicato astratto. Se la Classe si fa concreta, si in-stanzia, ossia si in-pone nella realtà concreta del programma, diventa gestibile in modo effettivo, virtualmente tangibile: diventa un Oggetto. L'Oggetto si pone, sta nel mondo del programma informatico con una sua individualità definita e condizionata da funzionalità e caratteristiche che rimandano necessariamente alla sua Classe di appartenenza.
Un Oggetto è in vero un'allocazione di memoria necessaria a far "esistere" l'Oggetto creato (che coincide con la variabile stessa). In particolare verrà allocata ed occupata la necessaria memoria per la Classe, e per l'Oggetto, nonché per le eventuali assegnazioni alle proprietà di quell'Oggetto.
Tali istanze concrete di una Classe, gli Oggetti, singolarità di una Classe, essendo previste per l'occasione in un determinato contesto di codice, per esistere devono, come ogni entità concreta immanente, essere specificamente create; e in particolare gli Oggetti devono essere creati all'interno del codice mediante la parola-chiave "New", e possono essere distrutte durante il programma con il Metodo ".Delete" o al termine della loro visibilità.
La Classe, invece, non è creabile mediante la parola-chiave "New"; essa può essere creata nativamente in Gambas oppure ad hoc dal programmatore in fase progettuale.

La Classe, nonostante sia un'entità che semplicemente dichiara alcune funzionalità e proprietà (che potranno essere effettivamente utilizzate nel codice mediante i suoi Oggetti), non è una entità assolutamente inconsistente. Essa, affinché possa esistere, occupa comunque in concreto una certa quantità di memoria. Pertanto, con la creazione di una Classe e successivamente del suo correlato Oggetto, viene occupata una certa quantità di memoria sia per l'esistenza della Classe, sia per l'esistenza dell'Oggetto, nonché per la eventuale memorizzazione dei valori assegnati a sue specifiche proprietà.

Il Modulo

Il Modulo è una sorta di Classe che può essere fornita di Proprietà e di Metodi, ma è incapace di sollevare propri Eventi mediante la parola-chiave Event, poiché la risorsa dell'Evento non gli appartiene. Ciò però non impedisce che al suo interno possano essere sollevati Eventi appartenenti a delle specifiche Classi.
Il Modulo viene altresì definito come Classe statica, potendosi creare regolarmente Istanze individuali, singoli Oggetti di un Modulo mediante la parola-chiave "New"; ma i Simboli delle Istanze di un Modulo non sono suscettibili di diretta lettura né di assegnazione diretta di valori, restando questa caratteristica una prerogativa del Modulo, del quale quegli Oggetti sono Istanze. Da ciò si deduce che la creazione di Istanze individuali di un Modulo non possiede alcuna utilità pratica.
La Staticità del Modulo si afferma più in relazione alle sue ipotetiche Istanze individuali (che - come ormai si sa - risultano essere inutili), che alla presunta capacità di conservare i valori precedentemente assegnati. Anzi, con riferimento a tale capacità si può anche aggiungere che la Staticità di un Simbolo di un Modulo sussiste solo qualora la sua Visibilità sia Pubblica.

Visibilità delle Variabili

Visibilità all'interno della Classe e del Modulo: "Globale" e "Locale"

La "Globalità " attiene all'attitudine, alla capacità di una variabile di essere vista (scope) all'interno di una Classe o di un Modulo creati, automaticamente o arbitrariamente.
In termini di allocazione della memoria si ha una variabile "Globale", quando detta area di memoria resta riservata dal sistema in favore del programma sino alla chiusura del programma medesimo.
Pertanto, una Variabile "Globale" sarà visibile (ossia potrà essere invocata ed utilizzata) in un qualunque parte della Classe o del Modulo ove essa è stata "dichiarata" ^{[nota 1]} .

Se invece una variabile è "Locale", essa non è visibile all'interno di una Classe o di un Modulo. Più precisamente essa non può essere utilizzata al di fuori della routine ove è stata dichiarata.
I casi espliciti di variabili locali sono le variabili dichiarate all'interno di una sub-routine:

Dim vr As Integer

o dei parametri formali di una Funzione o di una Procedura chiamata:

Function Nome_Funzione(vr As Integer)

Come già detto, in questi casi le variabili, essendo locali, non sono leggibili né scrivibili (non le si può assegnare valori) nelle altre routine.
Insomma, le variabili locali non possono essere richiamate nelle routine diverse da quelle ove furono dichiarate. Si dice che la vita di una variabile locale inizia e finisce nel solo ambito della routine ove sia stata dichiarata: essa può essere utilizzata esclusivamente in tale ambito.
In termini di allocazione della memoria si ha una variabile "Locale", quando detta area di memoria resta riservata dal sistema in favore del programma dal punto di dichiarazione nella routine sino all'uscita dalla routine medesima.

Visibilità verso altre Classi: "Pubblico" e "Privato"

La "Pubblicità " di una Variabile o di una Costante è l'attitudine a essere "vista" (ossia ad essere invocata ed utilizzata) anche nelle altre Classi o Moduli creati.
Pertanto, se in un progetto sussistono più Classi e/o più Moduli, una Variabile o una Costante, se è dichiarata Pubblica in una Classe o in un Modulo, potrà essere letta e le si potranno assegnare valori anche dalle altre Classi o Moduli.
Va da sé che, invece, una Variabile o una Costante dichiarata come Privata non può essere richiamata da altre Classi o Moduli esistenti.

Come sappiamo, in Gambas per dichiarare una Variabile o una Costante, quale Pubblica o Private, vanno utilizzate le parole-chiave "Public" e "Private" poste all'inizio del codice e all'esterno delle routine ^{[nota 2]}:

Private varpr As Integer

Public varpu As Integer

Private Const COSPR As Integer = 1000

Public Const COSPU As Integer = 12345


Public Sub Main()

.......

Da quanto detto deriva che ogni Variabile e ogni Costante espressamente dichiarata Pubblica o Privata è sempre Globale.

Persistenza di una Classe e di un Oggetto

Persistenza di una Classe e persistenza di un simbolo di un Oggetto verso altri Oggetti dichiarati della medesima Classe: "Statico" e "Dinamico"

Come è noto, una variabile (che qui, per comodità, chiameremo "var") posta in una Classe può essere "vista", ossia letta e modificata, da un'altra Classe, solo se tale variabile "var" è impostata come "Globale" e pubblica mediante la parola-chiave "Public".
Ovviamente il valore di questa variabile "var", pur essendo "Globale" e "Pubblica", non persiste, non si conserva nella omonima variabile di eventuali altri Oggetti dichiarati della medesima Classe di appartenenza della variabile "var".
Affinché il valore della variabile "var" si conservi, persista (come se si trasferisse, si attribuisse) nelle variabili degli eventuali altri Oggetti, appartenenti alla medesima Classe alla quale appartiene la variabile "var", è necessario che tale variabile "var" sia dichiarata come statica mediante la parola-chiave "Static". La parola-chiave "Static" fa sì che il valore di una variabile di una Classe, attribuito con la chiamata da parte di un Oggetto appartenente a quella Classe, sia riscontrabile anche nella omonima variabile chiamata da eventuali altri Oggetti appartenenti alla quella medesima Classe.

Vediamo un esempio, nel quale abbiamo la seguente Classe principale:

Public Sub Form_Open()
 
  Dim cl1, cl2, cl3 As New Class1
  
  cl1.Prova()
  Print cl1.Ritorna(), cl1.n
   
  Print cl2.Ritorna(), cl2.n
  
  Print cl3.Ritorna(), cl3.n
  
End

e una Classe secondaria, chiamata "Class1":

Static Private i As Integer
Public n As Integer

Public Procedure Prova()
 
  i = 99
  n = 100
 
End


Public Function Ritorna() As Integer
 
  Return i
 
End

Come si può notare, la variabile "n" (appartenente alla variabile "cl1" dichiarata come Oggetto della Classe secondaria "Class1.class"), nonostante sia globale e pubblica, è visibile soltanto se essa viene richiamata dalla Classe principale (in questo caso FMain.class) dopo essere stata opportunamente valorizzata attraverso la chiamata dell'Oggetto "cl1", al quale essa appartiene. Nel caso in cui la variabile "n" (appartenente alle variabili "cl2" e cl3"), non essendo stata opportunamente valorizzata, viene richiamata dalla Classe principale, essa restituisce il valore 0.
Diversamente la variabile "i" viene valorizzata con la chiamata dell'Oggetto "cl1", ed essendo stata dichiarata anche statica, conserva il suo valore, nonostante sia "privata", anche quando saranno chiamate le omonime variabili "i" dagli Oggetti "cl2" e cl3" (che sono dichiarati comunque della medesima Classe alla quale appartiene l'Oggetto "cl1".
Pertanto la parola-chiave "Static" consente di conservare il valore di una variabile di Oggetto anche nelle omonime variabili di altri Oggetti dichiarati della medesima Classe, della quale la variabile - dichiarata statica - è un simbolo.
Come si può notare infatti nel precedente esempio, il valore della variabile statica "i" resta conservato nella variabile "i" chiamata dagli Oggetti "cl2" e "cl3" senza che sia necessario richiamare per questi Oggetti la rispettiva Procedura "Prova()".

Note

[1] "Dichiarare" significa specificare il tipo di dati di una variabile.

[2] Da ciò possiamo dire che le "Variabili" locali sono sostanzialmente anche sempre Private.