Vuott il 14:35, 22 ago 2025

2025-08-22T14:35:42Z

← Versione meno recente		Versione delle 08:35, 22 ago 2025
Riga 1:		Riga 1:
	Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. <SUP>[[[#Note\|~~Nota~~ 1]]]</sup>		Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. <SUP>[[[#Note\|nota 1]]]</sup>

	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.		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.
Riga 27:		Riga 27:
	='''_new()''' - Il Costruttore=		='''_new()''' - Il Costruttore=
	Il ''Costruttore'' "_New()" è un Metodo nascosto che viene eseguito al momento della costruzione dell'Oggetto (come fosse un Evento speciale della Classe a cui appartiene).		Il ''Costruttore'' "_New()" è un Metodo nascosto che viene eseguito al momento della costruzione dell'Oggetto (come fosse un Evento speciale della Classe a cui appartiene).
	<BR>Esso può ricevere argomenti passati all'atto della creazione dell'Oggetto della Classe specifica mediante la parola-chiave "New". <SUP>[[[#Note\|~~Nota~~ 2]]]</sup>		<BR>Esso può ricevere argomenti passati all'atto della creazione dell'Oggetto della Classe specifica mediante la parola-chiave "New". <SUP>[[[#Note\|nota 2]]]</sup>

	Come già detto, il Metodo nascosto '''[https://gambaswiki.org/wiki/dev/api/cat/special/_new _New()]''' si comporta come un Evento: esso - se previsto in codice - si solleva all'atto della creazione di una Classe.		Come già detto, il Metodo nascosto '''[https://gambaswiki.org/wiki/dev/api/cat/special/_new _New()]''' si comporta come un Evento: esso - se previsto in codice - si solleva all'atto della creazione di una Classe.

Vuott: Creata pagina con "Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. ^{[#Note|Nota..."}

2025-08-22T14:34:11Z

Creata pagina con "Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. [#Note|Nota..."

Nuova pagina

Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. [[[#Note|Nota 1]]]

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'' che in quelle ''statiche''.

I Metodi ''nascosti'' più importanti, sono:
Public Sub '''_new()'''
e
Public Sub '''_free()'''
rispettivamente:

* _new(): creazione dell'oggetto;
* _free(): distruzione dell'oggetto;

* _new() può essere usato per passare dei parametri all'oggetto, proprio nella fase di creazione (non di apertura), e può essere utilizzato anche per creare oggetti all'interno di una ''Form''.
* _free() viene chiamato giusto nella fase finale di eliminazione dell'oggetto dalla memoria. Può essere utilizzato, ad esempio, per terminare un ''timer'' (se si verifica un errore), oppure per chiudere un'attività, a prescindere dal resto.

Queste due funzioni, dunque, sono sempre e comunque chiamate (indipendentemente se dichiarate esplicitamente nel codice o meno) da Gambas, quando l'oggetto viene creato e distrutto, anche se non sono presenti nel codice dell'oggetto, perché esistono comunque nella classe base di tutti gli oggetti creati in Gambas (''Object'' ).

L'Oggetto deve essere esplicitamente ''creato'', ovvero ''fornita sufficiente memoria per contenerlo'', poi deve essere chiamato il suo costruttore. In Gambas questo procedimento è implicito con l'uso dell'istruzione NEW. Tale istruzione, infatti, provoca prima la creazione in memoria dell'Oggetto, poi esegue il suo costruttore, in tutti i casi il metodo nascosto "_new()".

Inoltre, ogni oggetto prevede anche un metodo distruttore, che in gambas viene assunto da un altro metodo nascosto _free().
 Gambas infine chiama automaticamente "_free()" e "_delete()", quando l'Oggetto non viene più usato.

='''_new()''' - Il Costruttore=
Il ''Costruttore'' "_New()" è un Metodo nascosto che viene eseguito al momento della costruzione dell'Oggetto (come fosse un Evento speciale della Classe a cui appartiene).
 Esso può ricevere argomenti passati all'atto della creazione dell'Oggetto della Classe specifica mediante la parola-chiave "New". [[[#Note|Nota 2]]]

Come già detto, il Metodo nascosto '''[https://gambaswiki.org/wiki/dev/api/cat/special/_new _New()]''' si comporta come un Evento: esso - se previsto in codice - si solleva all'atto della creazione di una Classe.
 In esso si possono definire e impostare i valori base e le proprietà dell'Oggetto, e questo anche se è un Oggetto grafico (es. una ''Form'' ).

L'istruzione "_new()" viene sempre eseguita, sia negli oggetti statici, che negli altri, solo che verrà eseguita esclusivamente alla prima chiamata di un qualsiasi loro Metodo.

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 nascosto "_new()" (il Costruttore!). [[[#Note|nota 3]]]

Non esistono limitazioni sulla posizione del metodo all'interno del codice, ma, se presente, verrà comunque 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'''

==Passare dati ad un Oggetto all'atto della sua creazione==
Se si intende passare dati a un Oggetto di una Classe specifica, ciò va fatto all'atto della sua creazione con la parola-chiave "New" passando uno o più argomenti:
oggetto = New Classe_Specifica(argomento_1, argomento_2, etc...)
Tali dati passati come argomenti, affinché possano essere effettivamente ricevuti ed utilizzati dall'Oggetto, dovranno essere previsti esplicitamente come parametri del Medoto nascosto "_new()" nel codice della sua Classe specifica:
Public Sub _new(parametro_1 As tipo_di_dato, parametro_2 As tipo_di_dato, etc...)

End
all'interno possono essere assegnati i parametri ad altrettante Proprietà dell'oggetto, o condizionarne il funzionamento (es. definire le dimensioni iniziali di una ''Form'').

='''_free()''' - Il Distruttore=
Come esiste un '''Costruttore''', esiste 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 (come fosse un Evento speciale della Classe a cui appartiene) [[[#Note|nota 3]]], e che di solito viene usato per liberare la memoria allocata dalla Classe (ma non la memoria della Classe !). Più in particolare '''il ''Distruttore'' non distrugge l'Oggetto (che viene cancellato dal Metodo ".Delete()", risorsa dell'Oggetto medesimo), ma la memoria allocata dai Metodi dell'Oggetto'''.

Il Metodo nascosto '''[https://gambaswiki.org/wiki/dev/api/cat/special/_free _Free()]''' è utilizzabile per pulire determinate situazioni (es. una connessione), che magari non sono state completate correttamente a causa di un'errore nella classe. Il Metodo nascosto "_free()" è in pratica il distruttore della Classe, cioè viene chiamato un attimo prima che questa venga eliminata dalla memoria, ed è utile per pulire l'Oggetto da eventuali riferimenti ad altre Classi, o per chiudere eventuali aperture di ''stream''.

All'interno di questo Metodo nascosto, bisogna controllare (un "IF" di controllo può bastare sicuramente) se le variabili e le proprietà dello stesso siano ancora valide, ovvero non siano già state ''Nullate'' dalla procedura automatica di eliminazione dell'oggetto. Infatti potrebbe esserci una Proprietà della Classe che si sta cancellando, che punta ad un Oggetto esterno che non è più valido. In questo caso, andando ad effettuare dei controlli su questa Proprietà, in realtà si potrebbero trovare in due stadi:
 '''1''') la proprietà è ancora valida, ovvero il riferimento punta ad un oggetto ancora valido;

'''2''') l'oggetto non esiste più, per cui il "''riferimento'' " contiene un indirizzo non più valido, e quindi si potrebbe trovare ''Null'' oppure qualcosa di indefinito. In quest'ultimo caso è possibile usare i metodi di ''Object'', per controllare in che stato l'oggetto sia.
 Per "''riferimento'' " si intende tutto quello che non è intrinseco alla Classe stessa.
 Se ad esempio si ha un Oggetto grafico di tipo ''Button'' nella ''Form'', che è stata inserita fissa tramite l'editor grafico di [[GAMBAS|Gambas]], questa viene eliminata automaticamente da Gambas.
 Se si ha una variabile che contiene il riferimento ad un altro Oggetto fuori della Classe, Gambas non lo elimina, perché potrebbe essere un Oggetto valido, a prescindere dalla cancellazione di quella Classe. In tal caso, se questo riferimento è da considerarsi non più utile, nel senso che il programmatore non lo intende valido, allora deve essere eliminato.
 Se si ha un array di tipo ''String'', questo viene pulito perché contiene dati di livello base (''String'' fa parte di questo gruppo, anche se è in realtà un Oggetto).
 Se si ha un array di tipo ''Integer'', anche questo viene eliminato e pulita automaticamente.
 Se però la proprietà contiene un oggetto che è utilizzato esclusivamente all'interno della Classe, e non viene né istanziato, né utilizzato da codice esterno, allora anche questa proprietà viene pulita correttamente.

 Facciamo un paio di esempi.

Come primo esempio poniamo il caso di avere due classi: Classe1 e Classe2.
 Mettiamo che Classe2 abbia una proprietà di tipo Classe1, e che in qualche Metodo gli venga assegnato un oggetto valido ovviamente dello stesso tipo. Quando si va ad eliminare Classe2, l'oggetto Classe1 è sempre vivo, perché assegnato in maniera dinamica dall'esterno, quindi Gambas non può e non deve eliminarlo, in quanto è valido all'interno del progetto. In questo caso è necessario de-referenziare la proprietà della Classe2, mettendola a ''NULL'', e quindi eliminando il puntamento.
 Comunque, Classe1 continua sempre a vivere, e continuerà ad esserlo anche se viene posta a ''NULL'' la proprietà di Classe2, perchè non è essa quella che ha creato Classe1, ma ne teneva solo l'indirizzo in memoria.
 L'eliminazione di Classe1 deve essere fatta solo da chi l'ha creata !

Nel secondo esempio, poniamo il caso di avere prima l'assegnazione del testo presente in una ''TextLabel1'' alla proprietà ''.Text'' di un ''Button1'', e successivamente la cancellazione di ''TextLabel1.Text''.
 In questo caso viene assegnato un valore stringa, che è un tipo di dato base, e che in Gambas viene passato come valore, quindi una copia conforme all'originale. Se si cancella ''TextLabel1.Text'', il valore in ''Button1.Text'' viene mantenuto, perchè è un clone indipendente. Stessa cosa se si modifica l'uno rispetto all'altro, i due valori sono distinti, dalla copia in poi.
 Poniamo il caso che si intenda mantenere un riferimento all'oggetto ''TextLabel1'', per generica utilità all'interno del progetto. Supponiamo quindi sia stata creata una variabile ''$Txlb'', a cui poi si assegni l'oggetto ''TextLabel1'', questa variabile riceverà il puntatore a ''TextLabel1'', ovvero l'indirizzo in memoria dell'oggetto ''TextLabel1'' (non una copia), per cui qualsiasi operazione si fa attraverso ''$Txlb'' si rifletterà su ''TextLabel1''. Se, in ipotesi, si decide di eliminare ''$Txlb'', questo non eliminerà però l'oggetto originale, e quindi ''TextLabel1'' continuerà ad esistere. Per tanto, se si intende eliminare ''TextLabel1'', bisognerà per forza utilizzare la Classe che lo contiene, di cui ha la ''paternità'', e che avrà il compito di eliminare i suoi oggetti. Per lo stesso motivo, se elimina il ''padre'', ad esempio una ''Form'', questa eliminerà prima tutti i suoi ''children'', e poi se stessa.
 Ritornando alla variabile ''$Txlb'', che supponiamo sia una Proprietà di una Classe ''specifica''. Se si va ad eliminare la detta Classe specifica, bisognerà anche pulire tutti i riferimenti che ha, compresi quelli dei suoi ''figli''. Quindi, essendo ''$Txlb'' un ''riferimento'' ad un oggetto esterno, bisognerà eliminare l'aggancio che ''$Txlb'' ha con questo oggetto, semplicemente mettendolo a ''Null'' (riferimento nullo, o ''void''). Questa operazione è necessaria, in quanto Gambas non lo fa in questo caso, perchè non può sapere che uso si sta facendo della classe, ed è per questo motivo che ogni oggetto ha un metodo distruttore: appunto "_free()".
 In altri linguaggi il concetto è identico, anche se la sintassi è diversa. In C++ e Java, per esempio, la definizione del costruttore e del distruttore è obbligatoria, anche se non necessariamente codificata. Il costruttore è in pratica il punto d'ingresso della classe, e che si occupa dell'attivazione della stessa e dei suoi elementi. Il distruttore è quello che si occupa di eliminare tutte le tracce in memoria della classe, una volta che non serve più.

Come si è detto in precedenza, vanno fatti dei controlli, ma le operazioni vanno fatte solo se gli oggetti sono validi, e non se sono invalidi. Se v'è un oggetto valido, è possibile pulire la proprietà che lo contiene, relativa all'oggetto che contiene "_free()".
 Riguardo al dopo non si deve fare nulla, e non si deve restituire nulla. Il metodo "_free()" non è reversibile, ma permette di fare gli ultimi ritocchi per pulire bene la memoria. A volte la pulizia automatica di Gambas non fa completamente il suo dovere, anche perché molte cose non può, e non deve, toccarle. A questo punto sta al programma controllare lo stato delle cose e agire di conseguenza. La mancata pulizia degli oggetti, fa sì che vengano emessi messaggi di ''Warning'' alla chiusura dell'applicazione che, appunto, indicano che ci sono oggetti ancora attivi in memoria.
La cosa, ad ogni modo, non è sia bloccante, è esclusivamente una questione di pulizia. Tutto quello che è stato utilizzato dal programma, viene ignorato dal sistema operativo, e reso mediamente disponibile.
 Questo però non realmente valido, se vi sono dei processi in ''background'', cui nessuno si occupa di eliminarli fisicamente dalla memoria. Di solito questi processi, se non vengono chiusi e puliti correttamente, restano come "''zombie''" nel sistema, e solo un "''kill -9'' " può eliminarli. ...ma per fortuna stiamo parlando di Linux, per cui processi impazziti non sono realmente un problema.
----

=Note=
[1] Riportiamo in questa pagina in modo più organico semplicemente diversi interventi e messaggi scritti su quest'argomento dall'utente ''md9327'' del forum ''Gambas-it.org'' .

[2] In sostanza va tenuto presente che, se in una ''Classe'' è stato posto il Metodo nascosto ''_new( )'':
 - - - - all'atto della creazione di tale ''Classe'' - per mezzo della parola-chiave ''New'' - viene immediatamente invocato il predetto Metodo nascosto ''_new( )'';
 - - - - è possibile passare mediante il Metodo nascosto ''_new( )'' uno o più parametri alla nuova ''Classe'' immediatamente e contestualmente all'atto della sua creazione (effettuata con la parola-chiave ''New''), come nell'esempio che segue:
 - - - - se ad esempio nella ''Classe'' principale viene creata la ''Classe'' secondaria passando a quest'ultima un parametro di tipo ''Stringa'':
Dim cl As Classe_secondaria

cl = '''New''' Classe_secondaria("testo qualsiasi")
- - - - nella ''Classe'' secondaria il parametro verrà immediatamente recepito, prima di ogni altro metodo in essa eventualmente presente, appunto con il Metodo nascosto ''_new( )'' e gestito di conseguenza come di consueto:
Public Sub '''_new'''(s As String)

Print s

End

[3] Facciamo ora un semplice esempio utilizzando due Classi: una Classe principale e una Classe secondaria.
 La Classe principale (chiamata "FMain") avrà al suo interno il seguente codice:
Private cl1 As Class1

' ''Questo Metodo nascosto della Classe principale viene sollevato all'atto della creazione della Classe principale medesima:''
Public Sub '''_new()'''

Print "Classe Principale in creazione"

' ''In questo caso all'atto della creazione della Classe principale si provvede anche creare una Classe "secondaria" (chiamata "Class1") inviandole pure alcuni argomenti:''
cl1 = New Class1("Testo qualsiasi", 4444)

End

Public Sub Button1_Click()

' ''Si provvede a distruggere la Classe "secondaria" assegnando "Null" alla variabile che punta al suo Oggetto. (è opportuno ricordare che una Classe secondaria può essere distrutta soltanto dalla Classe che l'ha generata).''
cl1 = Null

End
Mentre il codice nella Classe "secondaria" sarà il seguente:
' ''Questo Metodo nascosto della Classe "secondaria" viene sollevato all'atto della creazione della Classe "secondaria" medesima, e riceve gli argomenti passati con l'istruzione della creazione della Classe "secondaria" mediante la parola-chiave "New":''
Public Sub _new(s As String, i As Integer)

Print "Classe secondaria in creazione"

Print s, i

End

' ''Questo Metodo nascosto della Classe "secondaria" viene sollevato all'atto della "distruzione" della Classe "secondaria" medesima:''
Public Sub '''_free()'''

Print "Classe secondaria in distruzione"

End
Insomma, i Metodi nascosti "_new()" e "_free()" non creano e non distruggono direttamente alcunché: essi, comportandosi come degli Eventi, sono sollevati rispettivamente all'atto della creazione e all'atto della distruzione della Classe di riferimento.

Metodi nascosti: New() e Free() - Cronologia

Vuott il 14:35, 22 ago 2025

Vuott: Creata pagina con "Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. [#Note|Nota..."

Vuott: Creata pagina con "Ogni '''Oggetto''' ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. ^{[#Note|Nota..."}