Lezioni: programmazione Orientata agli Oggetti - Cronologia

Vuott il 00:05, 23 ago 2025

2025-08-23T00:05:56Z

← Versione meno recente		Versione delle 18:05, 22 ago 2025
Riga 50:		Riga 50:
	<BR>I casi espliciti di variabili ''locali'' sono le variabili dichiarate all'interno di una sub-routine:		<BR>I casi espliciti di variabili ''locali'' sono le variabili dichiarate all'interno di una sub-routine:
	Dim '''vr''' As Integer		Dim '''vr''' As Integer
	o dei parametri formali di una ''~~funzione~~'' o di una ''Procedura'' chiamata:		o dei parametri formali di una ''Funzione'' o di una ''Procedura'' chiamata:
	Function Nome_Funzione('''vr''' As Integer)		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. <BR>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.		Come già detto, in questi casi le variabili, essendo ''locali'', non sono leggibili né scrivibili (non le si può assegnare valori) nelle altre routine. <BR>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.
	<BR>In termini di allocazione della ~~memroria~~ 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.		<BR>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"==		==Visibilità verso altre Classi: "Pubblico" e "Privato"==

Vuott il 00:01, 23 ago 2025

2025-08-23T00:01:51Z

← Versione meno recente		Versione delle 18:01, 22 ago 2025
Riga 20:		Riga 20:
	La ''[[Oggetti, Classi e Moduli\|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, Classi e Moduli\|Oggetti]]'''''.		La ''[[Oggetti, Classi e Moduli\|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, Classi e Moduli\|Oggetti]]'''''.
	<BR>Gli ''[[Oggetti, Classi e Moduli\|Oggetti]]'' sono insomma quelle entità particolari, di cui si è parlato in principio, ma la ''[[Oggetti, Classi e Moduli\|Classe]]'' sia concettualmente che informaticamente in POO viene prima dell'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i>: essa è il presupposto dell'esistenza dell'''[[Oggetti, Classi e Moduli\|Oggetto]]'' (ossia della variabile del tipo di quella ''[[Oggetti, Classi e Moduli\|Classe]]'').		<BR>Gli ''[[Oggetti, Classi e Moduli\|Oggetti]]'' sono insomma quelle entità particolari, di cui si è parlato in principio, ma la ''[[Oggetti, Classi e Moduli\|Classe]]'' sia concettualmente che informaticamente in POO viene prima dell'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i>: essa è il presupposto dell'esistenza dell'''[[Oggetti, Classi e Moduli\|Oggetto]]'' (ossia della variabile del tipo di quella ''[[Oggetti, Classi e Moduli\|Classe]]'').
	<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' è la "definizione" di una realtà, ed anzi una realtà che "definisce" e "raggruppa" delle caratteristiche specifiche (si pensi ad esempio alla ''[[Oggetti, Classi e Moduli\|Classe]]'' "Button"); l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> è la realtà che il programmatore crea nel codice per utilizzare le risorse della ''[[~~Gli_Oggetti_e_le_Classi~~\|Classe]]''. In tal senso la ''[[Oggetti, Classi e Moduli\|Classe]]'' "raggruppa" anche gli eventuali ''[[Oggetti, Classi e Moduli\|Oggetti]]'' che, creati, ad essa si riferiscono.		<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' è la "definizione" di una realtà, ed anzi una realtà che "definisce" e "raggruppa" delle caratteristiche specifiche (si pensi ad esempio alla ''[[Oggetti, Classi e Moduli\|Classe]]'' "Button"); l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> è la realtà che il programmatore crea nel codice per utilizzare le risorse della ''[[Oggetti, Classi e Moduli\|Classe]]''. In tal senso la ''[[Oggetti, Classi e Moduli\|Classe]]'' "raggruppa" anche gli eventuali ''[[Oggetti, Classi e Moduli\|Oggetti]]'' che, creati, ad essa si riferiscono.
	<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' pre-esiste all'Oggetto, essendo possibile avere comunque una ''[[Oggetti, Classi e Moduli\|Classe]]'', ma è possibile evitare di creare l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> mediante "New". Una ''[[Oggetti, Classi e Moduli\|Classe]]'' può esistere pur non esistendo un suo ''[[Oggetti, Classi e Moduli\|Oggetto]]'', un suo <U>esemplare</u> concreto utilizzabile nel codice. Invece non esiste un ''[[Oggetti, Classi e Moduli\|Oggetto]]'' che non si riferisca ad una qualche ''[[Oggetti, Classi e Moduli\|Classe]]''. Infatti, quando esso viene creato, viene sempre riferito ad "una" specifica "''[[Oggetti, Classi e Moduli\|Classe]]''".		<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' pre-esiste all'Oggetto, essendo possibile avere comunque una ''[[Oggetti, Classi e Moduli\|Classe]]'', ma è possibile evitare di creare l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> mediante "New". Una ''[[Oggetti, Classi e Moduli\|Classe]]'' può esistere pur non esistendo un suo ''[[Oggetti, Classi e Moduli\|Oggetto]]'', un suo <U>esemplare</u> concreto utilizzabile nel codice. Invece non esiste un ''[[Oggetti, Classi e Moduli\|Oggetto]]'' che non si riferisca ad una qualche ''[[Oggetti, Classi e Moduli\|Classe]]''. Infatti, quando esso viene creato, viene sempre riferito ad "una" specifica "''[[Oggetti, Classi e Moduli\|Classe]]''".

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

	[2] Da ciò possiamo dire che le "Variabili" ''locali'' sono sostanzialmente anche <~~SPAN Style="text-decoration:underline"~~>sempre</~~span~~> ''Private''.		[2] Da ciò possiamo dire che le "Variabili" ''locali'' sono sostanzialmente anche <U>sempre</u> ''Private''.

Vuott il 14:59, 22 ago 2025

2025-08-22T14:59:48Z

← Versione meno recente		Versione delle 08:59, 22 ago 2025
Riga 21:		Riga 21:
	<BR>Gli ''[[Oggetti, Classi e Moduli\|Oggetti]]'' sono insomma quelle entità particolari, di cui si è parlato in principio, ma la ''[[Oggetti, Classi e Moduli\|Classe]]'' sia concettualmente che informaticamente in POO viene prima dell'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i>: essa è il presupposto dell'esistenza dell'''[[Oggetti, Classi e Moduli\|Oggetto]]'' (ossia della variabile del tipo di quella ''[[Oggetti, Classi e Moduli\|Classe]]'').		<BR>Gli ''[[Oggetti, Classi e Moduli\|Oggetti]]'' sono insomma quelle entità particolari, di cui si è parlato in principio, ma la ''[[Oggetti, Classi e Moduli\|Classe]]'' sia concettualmente che informaticamente in POO viene prima dell'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i>: essa è il presupposto dell'esistenza dell'''[[Oggetti, Classi e Moduli\|Oggetto]]'' (ossia della variabile del tipo di quella ''[[Oggetti, Classi e Moduli\|Classe]]'').
	<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' è la "definizione" di una realtà, ed anzi una realtà che "definisce" e "raggruppa" delle caratteristiche specifiche (si pensi ad esempio alla ''[[Oggetti, Classi e Moduli\|Classe]]'' "Button"); l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> è la realtà che il programmatore crea nel codice per utilizzare le risorse della ''[[Gli_Oggetti_e_le_Classi\|Classe]]''. In tal senso la ''[[Oggetti, Classi e Moduli\|Classe]]'' "raggruppa" anche gli eventuali ''[[Oggetti, Classi e Moduli\|Oggetti]]'' che, creati, ad essa si riferiscono.		<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' è la "definizione" di una realtà, ed anzi una realtà che "definisce" e "raggruppa" delle caratteristiche specifiche (si pensi ad esempio alla ''[[Oggetti, Classi e Moduli\|Classe]]'' "Button"); l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> è la realtà che il programmatore crea nel codice per utilizzare le risorse della ''[[Gli_Oggetti_e_le_Classi\|Classe]]''. In tal senso la ''[[Oggetti, Classi e Moduli\|Classe]]'' "raggruppa" anche gli eventuali ''[[Oggetti, Classi e Moduli\|Oggetti]]'' che, creati, ad essa si riferiscono.
	<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' pre-esiste all'Oggetto, essendo possibile avere comunque una ''[[Oggetti, Classi e Moduli\|Classe]]'', ma è possibile evitare di creare l'<I>[[~~Gli_Oggetti_e_le_Classi~~\|Oggetto]]</i> mediante "New". Una ''[[Oggetti, Classi e Moduli\|Classe]]'' può esistere pur non esistendo un suo ''[[Oggetti, Classi e Moduli\|Oggetto]]'', un suo <U>esemplare</u> concreto utilizzabile nel codice. Invece non esiste un ''[[Oggetti, Classi e Moduli\|Oggetto]]'' che non si riferisca ad una qualche ''[[Oggetti, Classi e Moduli\|Classe]]''. Infatti, quando esso viene creato, viene sempre riferito ad "una" specifica "''[[Oggetti, Classi e Moduli\|Classe]]''".		<BR>La ''[[Oggetti, Classi e Moduli\|Classe]]'' pre-esiste all'Oggetto, essendo possibile avere comunque una ''[[Oggetti, Classi e Moduli\|Classe]]'', ma è possibile evitare di creare l'<I>[[Oggetti, Classi e Moduli\|Oggetto]]</i> mediante "New". Una ''[[Oggetti, Classi e Moduli\|Classe]]'' può esistere pur non esistendo un suo ''[[Oggetti, Classi e Moduli\|Oggetto]]'', un suo <U>esemplare</u> concreto utilizzabile nel codice. Invece non esiste un ''[[Oggetti, Classi e Moduli\|Oggetto]]'' che non si riferisca ad una qualche ''[[Oggetti, Classi e Moduli\|Classe]]''. Infatti, quando esso viene creato, viene sempre riferito ad "una" specifica "''[[Oggetti, Classi e Moduli\|Classe]]''".

	La conoscenza delle caratteristiche specifiche di una ''[[Oggetti, Classi e Moduli\|Classe]]'' consente di conoscere le proprietà e le funzionalità, ossia le risorse, di ogni ''[[Oggetti, Classi e Moduli\|Oggetto]]'' appartenente a quella determinata ''[[Oggetti, Classi e Moduli\|Classe]]''.		La conoscenza delle caratteristiche specifiche di una ''[[Oggetti, Classi e Moduli\|Classe]]'' consente di conoscere le proprietà e le funzionalità, ossia le risorse, di ogni ''[[Oggetti, Classi e Moduli\|Oggetto]]'' appartenente a quella determinata ''[[Oggetti, Classi e Moduli\|Classe]]''.

Vuott il 14:07, 22 ago 2025

2025-08-22T14:07:09Z

← Versione meno recente		Versione delle 08:07, 22 ago 2025
Riga 8:		Riga 8:

	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.		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.		<BR>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.		<BR>L'allocazione di memoria diviene pertanto funzionale al raggiungimento di questo servizio.

Vuott il 14:04, 22 ago 2025

2025-08-22T14:04:37Z

← Versione meno recente		Versione delle 08:04, 22 ago 2025
Riga 76:		Riga 76:


	=Persistenza=		=Persistenza di una Classe e di un Oggetto=
	==Persistenza di una Classe e persistenza di un <U>simbolo</u> di un Oggetto verso altri Oggetti dichiarati della medesima Classe: "Statico" e "Dinamico"=0		==Persistenza di una Classe e persistenza di un <U>simbolo</u> 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".		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".
	<BR>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".		<BR>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".

Vuott il 14:03, 22 ago 2025

2025-08-22T14:03:46Z

← Versione meno recente		Versione delle 08:03, 22 ago 2025
Riga 55:		Riga 55:
	<BR>In termini di allocazione della memroria 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.		<BR>In termini di allocazione della memroria 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"=		==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) <U>anche nelle altre ''Classi'' o ''Moduli''</u> creati.		La "''Pubblicità'' " di una Variabile o di una Costante è l'attitudine a essere "vista" (ossia ad essere invocata ed utilizzata) <U>anche nelle altre ''Classi'' o ''Moduli''</u> creati.
	<BR>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''.		<BR>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''.

Vuott: Creata pagina con "L'intero codice, pensato e redatto dal programmatore, è finalizzato ad un concreto risultato: è scritto per fare ed ottenere qualcosa.
Le funzioni, espresse dai comandi,..."

2025-08-22T14:02:40Z

Creata pagina con "L'intero codice, pensato e redatto dal programmatore, è finalizzato ad un concreto risultato: è scritto per fare ed ottenere qualcosa. Le funzioni, espresse dai comandi,..."

Nuova pagina

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 '''''[[Oggetti, Classi e Moduli|Classe]]''''' di una o più istanze particolari che, possedendo tutte le risorse tipiche di quella ''[[Oggetti, Classi e Moduli|Classe]]'', consentono alla ''[[Oggetti, Classi e Moduli|Classe]]'' medesima di attuare le sue potenzialità ed al programmatore di utilizzare proficuamente quelle risorse dichiarate solo in astratto dalla ''[[Oggetti, Classi e Moduli|Classe]]''.

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

La conoscenza delle caratteristiche specifiche di una ''[[Oggetti, Classi e Moduli|Classe]]'' consente di conoscere le proprietà e le funzionalità, ossia le risorse, di ogni ''[[Oggetti, Classi e Moduli|Oggetto]]'' appartenente a quella determinata ''[[Oggetti, Classi e Moduli|Classe]]''.

Gli ''[[Oggetti, Classi e Moduli|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, Classi e Moduli|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 ''[[Oggetti, Classi e Moduli|Classe]]''. Mentre la ''[[Oggetti, Classi e Moduli|Classe]]'' esprime come mera possibilità alcune capacità e/o attributi, gli ''[[Oggetti, Classi e Moduli|Oggetti]]'' di tali ''[[Oggetti, Classi e Moduli|Classi]]'' mettono in atto, fattivamente, le capacità delle ''[[Oggetti, Classi e Moduli|Classi]]''. Se la ''[[Oggetti, Classi e Moduli|Classe]]'' è un'entità che esprime "in potenza" le sue funzionalità e proprietà che dichiara, gli ''[[Oggetti, Classi e Moduli|Oggetti]]'' rappresentano "in atto" tali caratteristiche. La ''[[Oggetti, Classi e Moduli|Classe]]'' dichiara in astratto ciò che l'''[[Oggetti, Classi e Moduli|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 ''[[Oggetti, Classi e Moduli|Oggetto]]'' è in vero un'allocazione di memoria necessaria a far "esistere" l'[[Oggetti, Classi e Moduli|Oggetto]] creato (che coincide con la variabile stessa). In particolare verrà allocata ed occupata la necessaria memoria per la ''[[Oggetti, Classi e Moduli|Classe]]'', e per l'[[Oggetti, Classi e Moduli|Oggetto]], nonché per le eventuali assegnazioni alle proprietà di quell'[[Oggetti, Classi e Moduli|Oggetto]].
 Tali istanze concrete di una Classe, gli ''[[Oggetti, Classi e Moduli|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 ''[[Oggetti, Classi e Moduli|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 ''[[Oggetti, Classi e Moduli|Classe]]'', nonostante sia un'entità che semplicemente dichiara alcune funzionalità e proprietà (che potranno essere effettivamente utilizzate nel codice mediante i suoi ''[[Oggetti, Classi e Moduli|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 ''[[Oggetti, Classi e Moduli|Classe]]'' e successivamente del suo correlato ''[[Oggetti, Classi e Moduli|Oggetto]]'', viene occupata una certa quantità di memoria sia per l'esistenza della ''[[Oggetti, Classi e Moduli|Classe]]'', sia per l'esistenza dell'''[[Oggetti, Classi e Moduli|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 ''[[Gli Eventi|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" [[[#Note|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 memroria 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 [[[#Note|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=
==Persistenza di una Classe e persistenza di un simbolo di un Oggetto verso altri Oggetti dichiarati della medesima Classe: "Statico" e "Dinamico"=0
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''.