Guide della comunità

2011-09-30T14:25:57Z

Migoy101:

Raccolta di guide sui componenti, sui metodi e sugli algoritmi del linguaggio Gambas scritti e mantenuti dalla comunità italiana Gambas-it

== Componenti ==

* [[Come creare un componente]]

* [[Tutorial - creare un componente: il frame]]

==== Componenti della Comunità Gambas-it.org ====

* [[GridBox]]

== Interfacciare Gambas con librerie esterne ==

* [[Documento originale (Inglese)]]
* [[Traduzione della comunità di Gambas-it]]

== Pdfwriter ==

*[[Guida ai report]]
*[http://safedietpillsthatworkfast.com/ safe diet pills that work]
*[http://thebeginnerslens.com/iphone photography]
*[http://www.proposable.comproposal software]

== Gestione dei dati MIDI ==

*[[Gestione del MIDI con O.S.S.]]

*[[Gestione del MIDI con ALSA]]

CREATE PRIVATE...CREATE STATIC

2011-07-30T13:51:35Z

Migoy101:

'''CREATE PRIVATE, CREATE STATIC'''

----

[Traduzione dalla pagina ufficiale di Gambas]
''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.''

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

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 può contenere vari tipi di elemento, da semplici [http://www.diamondlinks.net/ link building] 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:

----

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

----

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

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

----

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

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

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

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

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

Uno degli scopi fondamentali della logica a oggetti, è proprio quella di non dover scrivere più volte lo stesso codice, e un oggetto può essere riutilizzato più volte per situazioni diverse.
In questo modo possiamo creare oggetti diversi, derivati da una stessa fonte, ma che hanno specializzazioni diverse.
Diversamente da vecchie versioni di Gambas, in queste ultime release non sembra ci siano limiti nll'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...).
----

'''CREATE PRIVATE'''

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

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

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

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

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

'''CREATE STATIC'''

La frase chiave '''CREATE STATIC''', a differenza della precedente, dice all'inteprete 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...
Come per '''CREATE PRIVATE''', la sintassi deve trovarsi all'inizio del codice della classe, o subito dopo un'istruzione [[INHERITS]].
----

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

----

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

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

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

Gambas-it.org - Wikipedia - Contributi dell'utente [it]

Guide della comunità

CREATE PRIVATE...CREATE STATIC