CREATE PRIVATE...CREATE STATIC - Cronologia

Vuott il 23:43, 23 nov 2024

2024-11-23T23:43:02Z

← Versione meno recente		Versione delle 17:43, 23 nov 2024
Riga 137:		Riga 137:

	=Note=		=Note=
	[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Oggetto'' di quella Classe.		[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''[[Oggetti, Classi e Moduli\|Oggetto]]'' di quella Classe.
	<BR>L'<I>Oggetto</i> 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.		<BR>L'<I>Oggetto</i> 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'<I>istanza</i> (Oggetto) della Classe.		[2] A una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> (Oggetto) della Classe.

Vuott il 23:39, 23 nov 2024

2024-11-23T23:39:01Z

← Versione meno recente		Versione delle 17:39, 23 nov 2024
Riga 1:		Riga 1:
	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 già menzionato nella pagina "[[Oggetti, Classi e Moduli]]", 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.		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.

Vuott il 02:56, 27 ott 2024

2024-10-27T02:56:55Z

← Versione meno recente		Versione delle 20:56, 26 ott 2024
Riga 108:		Riga 108:
	<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>		<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>
	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.		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... <SUP>[[[#Note\|~~Nota~~ 2]]]</sup>		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... <SUP>[[[#Note\|nota 2]]]</sup>

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

Vuott il 02:55, 27 ott 2024

2024-10-27T02:55:42Z

← Versione meno recente		Versione delle 20:55, 26 ott 2024
Riga 3:		Riga 3:
	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.		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 <SUP>[[[#Note\|~~Nota~~ 1]]]</sup> a livello procedura, assume un contenuto e una forma in memoria reali, altrettanto viene fatto per una classe.		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 <SUP>[[[#Note\|nota 1]]]</sup> 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.		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:		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:
Riga 66:		Riga 66:

	=CREATE PRIVATE=		=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.''		« ''Queste due parole chiave, inserite all'inizio del codice di una classe, indicano all'interprete Gambas che la classe <U>non</u> può essere istanziata.''
	''Questa modalità viene usata per la costruzione di classi, padri di altre classi.'' "		''Questa modalità viene usata per la costruzione di classi, padri di altre classi.'' »
	<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>		<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>
	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:		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:
Riga 105:		Riga 105:

	=CREATE STATIC=		=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.'' »
			<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>
	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.		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... <SUP>[[[#Note\|Nota 2]]]</sup>		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... <SUP>[[[#Note\|Nota 2]]]</sup>

Vuott il 02:52, 27 ott 2024

2024-10-27T02:52:08Z

← Versione meno recente		Versione delle 20:52, 26 ott 2024
Riga 1:		Riga 1:
	~~'''CREATE PRIVATE, CREATE STATIC'''~~

	~~----~~
	~~" ''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.'' "~~
	~~<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>~~

	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 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.

Riga 69:		Riga 62:
	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...).		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'''~~; ammettiamo~~ 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...).		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...).
	~~----~~		<BR>Vediamo cosa succede con le due coppie di parole chiavi.


	~~'''CREATE PRIVATE'''~~

			=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.'' "
			<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>
	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:		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:
	----		----
Riga 110:		Riga 104:
	----		----

			=CREATE STATIC=
	~~'''~~CREATE STATIC~~'''~~

	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.		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.

Vuott il 22:54, 11 lug 2024

2024-07-11T22:54:49Z

← Versione meno recente		Versione delle 16:54, 11 lug 2024
Riga 143:		Riga 143:

	=Note=		=Note=
	[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''~~Ogqetto~~'' di quella Classe.		[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Oggetto'' di quella Classe.
	<BR>L'<I>Oggetto</i> 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.		<BR>L'<I>Oggetto</i> 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] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> (Oggetto) della Classe.		[2] A una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> (Oggetto) della Classe.

Vuott il 13:52, 6 lug 2024

2024-07-06T13:52:44Z

← Versione meno recente		Versione delle 07:52, 6 lug 2024
Riga 146:		Riga 146:
	<BR>L'<I>Oggetto</i> 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.		<BR>L'<I>Oggetto</i> 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] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.		[2] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> (Oggetto) della Classe.

Vuott il 13:52, 6 lug 2024

2024-07-06T13:52:15Z

← Versione meno recente		Versione delle 07:52, 6 lug 2024
Riga 144:		Riga 144:
	=Note=		=Note=
	[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Ogqetto'' di quella Classe.		[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Ogqetto'' di quella Classe.
	<BR>L'<I>Oggetto</i> 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.		<BR>L'<I>Oggetto</i> 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] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.		[2] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.

Vuott il 16:43, 11 ago 2020

2020-08-11T16:43:10Z

← Versione meno recente		Versione delle 10:43, 11 ago 2020
Riga 144:		Riga 144:
	=Note=		=Note=
	[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Ogqetto'' di quella Classe.		[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Ogqetto'' di quella Classe.
	<BR>L'<I>Oggetto</i> di una Classe è l'elemento del codice, con il quale sfruttare concretamente le funzionalità (''Proprietà'', ''Metodi'' ed ''Eventi'' della Classe alla quale esso appartiene.		<BR>L'<I>Oggetto</i> 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] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.		[2] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.

Vuott il 16:42, 11 ago 2020

2020-08-11T16:42:10Z

← Versione meno recente		Versione delle 10:42, 11 ago 2020
Riga 6:		Riga 6:
	<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>		<FONT Size=1>(Traduzione dalla pagina ufficiale di Gambas)</font>

	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 fà parte del concetto di oggetto (o classe), comune a tutti i linguaggi orientati agli oggetti.		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 ~~caratterische~~ di Gambas, collegando questo ad alcuni riferimenti e concetti generali.		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 a livello procedura, assume un contenuto e una forma in memoria reali, altrettanto viene fatto per una classe.		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 <SUP>[[[#Note\|Nota 1]]]</sup> 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.		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 fà parte dell'~~oggetto~~, può essere fatta tramite il puntamento al nome stesso della variabile/funzione, passando prima per il puntamento iniziale della ~~classe~~:		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:

	----		----
Riga 29:		Riga 29:
	----		----

	La logica degli oggetti permette di definire una serie di caratteristiche distinte legate all'~~oggetto~~ stesso.		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'':		Se associamo questa logica al mondo reale, possiamo fare un semplice esempio: immaginiamo di descrivere una matita (o lapis), utilizzando una Classe chiamata ''Matita'':

	----		----
Riga 61:		Riga 61:

	----		----
	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''.		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 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''.		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.		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.		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 ~~nll~~'inerenza di ~~classi~~ e ~~sottoclassi~~ (in alcuni miei programmi ho usato fino a 20 sottoclassi...).		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'''; ammettiamo 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...).		Ritornando alle parole chiave '''CREATE PRIVATE''' e '''CREATE STATIC'''; ammettiamo 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...).
	----		----

Riga 89:		Riga 89:

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

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

Riga 114:		Riga 114:

	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.		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... <SUP>[[[#Note\|Nota 1]]]</sup>		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... <SUP>[[[#Note\|Nota 2]]]</sup>

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

	----		----
	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.		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 pò come poi è il modulo in Gambas.		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=		=Note=
	[1] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.		[1] Quando una Classe viene " ''istanziata'' ", viene creato un ''Ogqetto'' di quella Classe.
			<BR>L'<I>Oggetto</i> di una Classe è l'elemento del codice, con il quale sfruttare concretamente le funzionalità (''Proprietà'', ''Metodi'' ed ''Eventi'' della Classe alla quale esso appartiene.

			[2] Ad una Classe ''statica'' si può accedere senza bisogno di creare un'<I>istanza</i> della Classe.