Versione delle 11:51, 17 mar 2013

Possiamo gestire le proprietà di una particolare Classe, da noi creata, mediante le variabili. In questo modo una Classe specifica appositamente creata può sostituire una Struttura, in quanto si riserva una quantità di memoria determinata dal tipo di variabili da esse formata.

Classe con dichiarazione e creazione di sue proprietà, come Funzioni, mediante Property

Possiamo creare una Classe specifica attribuando le sue proprietà interne mediante la parola chiave Property. Questa parola chiave consente di dichiarare una proprietà di una Classe specifica creata dall'utente.

Leggiamo dalla guida in linea:

In automatico una volta dichiarata una proprietà, l'editor di Gambas crea una funzione per la lettura e una subroutine per la scrittura della proprietà stessa.
Se invece opzionalmente viene utilizzata la parola chiave facoltativa READ, allora la proprietà così creata diventa a sola lettura, e l'editor di Gambas non crerà la subroutine di scrittura.
Una volta dichiarata nella classe specificata, una proprietà deve essere implementata. Si tratta in pratica di scrivere del codice nella funzione che legge la proprietà.
E se la proprietà non è a sola lettura, e cioè la si può anche scrivere, di scrivere del codice anche nella subroutine di scrittura.
Il nome della funzione per la lettura, è il nome della proprietà seguito da un carattere di sottolineatura e dalla parola Read.
Questa funzione così composta non necessita di argomenti e deve restituire un valore il cui tipo sia lo stesso dichiarato nella proprietà.
Il nome della subroutine di scrittura, è il nome della proprietà seguito da un carattere di sottolineatura e dalla parola Write.
Questa subroutine essendo tale non ritorna ovviamente niente, ma prende un argomento (uno solo) che gli viene passato che deve essere dello stesso tipo dichiarato nella proprietà
per poterlo poi assegnare alla funzione Read di lettura eventualmente elaborato.

Per dichiarare una proprietà è necessario utilizzare la parola chiave Property. |1|

Property Nome As Tipo

definisce una proprietà in lettura/scrittura

Property Read Nome as Tipo

definisce una proprietà in sola lettura.

Alla proprietà viene poi associato un simbolo dello stesso tipo per contenerne il valore.

Facciamo un esempio. Supponiamo di avere una classe Automobili, per ciascuna automibile bisognerà gestire diversi parametri:
- Colore
- Cilindrata
- Modello ...

definiremo quindi la Classe Automobile così come segue:

' Definisco le properità
Property Colore As Integer  
Property Modello As String  
Property Cilindrata As String  
 

Property Read Allestimento As String  
 
' Definisco i simboli associati alle proprietà...
Private $Colore As Integer
Private $Modello As String  
Private $Cilindrata As String  
Private $Allestimento As String  
 

Public Sub _new(versione As String)  

 $Allestimento = versione  

End  
 
 
' ...e funzioni utilizzate per gestire le proprietà:
Private Function Colore_Read() As Integer  
  Return $Colore  
End  
 
Private Sub Colore_Write(Value As Integer)  
 $Colore = Value  
End  
 
 
Private Function Modello_Read() As String  
 Return $Modello  
End  
 
Private Sub Modello_Write(Value As String)  
 $Modello = Value  
End  
 
 
Private Function Cilindrata_Read() As String  
 Return $Cilindrata  
End  
 
Private Sub Cilindrata_Write(Value As String)  
 $Cilindrata = Value  
End  
 
Private Function Allestimento_Read() As String
 Return $Allestimento  
End

Classe con dichiarazione di sole semplici variabili pubbliche

In modo più semplice è possibile creare una Classe specifica, da gestire poi ovviamente con una relativa variabile, con dichiarazione di sole semplici variabili pubbliche.

Leggiamo, infatti, dalla guida in linea relativa alla parola Property:

E' possibile evitare l'utilizzo delle proprietà con delle variabili pubbliche dichiarate all'interno della Classe.
Tutto ciò se pur più semplice ed ammesso e meno complesso presenta lo svantaggio che in qualsiasi parte del programma sia possibile modificare i valori senza nessun controllo,
o meglio il controllo deve essere fatto prima infrangendo il meccanismo dell'incasplulamento.
Se questo per piccoli programmi è accettabile non lo è per programmi più corposi. Infatti implementando le proprietà, è possibile controllare che la coerenza dei dati sia tale
in tutte le situazioni al di la della consistenza del programma.

Impostazione ed elementi interni della Classe particolare

Creiamo innanzitutto la nostra Classe particolare, che per esempio chiameremo "Clcreata.Class, e contenente quattro variabili: una di tipo Byte, una di tipo Integer, un'altra di tipo Stringa ed una di tipo Button.

Al suo interno scriveremo semplicemente le dichiarazioni di quelle quattro variabili come Pubbliche:

Public vB As Byte

Public vI As Integer

Public v$ As String

Public bu As Button

Nella Classe principale "FMain.Class" andiamo ad utilizzare la Classe particolare da noi creata. Tale uso lo vedremo nei paragrafi che seguono appresso.

Variabili del tipo della Classe specifica creata

La variabile per gestire le proprietà, oggetti, etc di una Classe particolare da noi creata deve essere del tipo di detta Classe particolare:

' Dichiariamo la variabile del tipo della Classe specifica:
 Private vrCl As Clcreata


Public Sub Button1_Click()

With vrCl = New Clcreata
 .vB = 1
 .vI = 1001
 .v$ = "prova" & .vB
End With


' Gestiamo ora la variabile di tipo Button, crandone un paio:

 With vrCl.bu = New Button(Me) As "bu"
   .X = 10
   .Y = 10
   .W = 100
   .H = 100
   .Text = "Bu"
 End With

 With vrCl.bu = New Button(Me) As "bu"
   .X = 200
   .Y = 10
   .W = 100
   .H = 100
   .Text = "Bu2"
 End With

End


Public Sub bu_Click()

 With vrCl
   Print .vB
   Print .vI
   Print .v$
 End With

Print Last.Text

End

Utilizzare una Classe particolare con una variabile Variant

Possiamo caricare anche in una variabile di tipo Variant le proprietà e gli elementi che costituiscono la nostra Classe particolare creata:

Public Sub Button1_Click()

Dim xx As Variant

 With xx = New Clcreata
   .vB = 19
   .vI = 1900
   .v$ = "prova" & .vB
End With

With xx
  Print .vB
  Print .vI
  Print .v$
End With

End

Uso di una variabile del dipo della Classe particolare e di una variabile Variant

Public Sub Button1_Click()

 Dim rr As Clcreata
 Dim vv As Variant

   With rr = New Clcreata
     .vB = 1
     .vI = 1001
     .v$ = "prova" & .vB
   End With


' Trasferiamo i valori da una variabile all'altra:
   ali = rr

   With ali
     Print .vB
     Print .vI
     Print .v$
   End With

End

Variabile array di tipo di una Classe creata

Possiamo gestire le proprietà di una particolare Classe, da noi creata, anche mediante una variabile array.

Nella Classe principale "FMain.Class" andiamo ad utilizzare la Classe particolare da noi creata, semplicemente creandone una variabile array e caricando i valori negli elementi di tale variabile array:

' Dichiara due variabili di tipo classe "Clval":
' una come array con numero di elementi non definito:
Private clval1 As New Clcreata[]


Public Sub Form_Open()
 Dim a As Byte
 Dim clval2 As Clcreata  '...ed un'altra ordinaria:


For a = 0 To 99

' assegna i valori ai campi della variabile di tipo classe "Clval":
 With clval2 = New Clcreata
   .vB = a
   .vI = 1000 + CInt(a)
   .v$ = "prova " & Str(a)
 End With
 
 clval1.Add(clval2)
 
Next

End


Public Sub Button1_Click()

Dim a As Byte

' mostra in console i risultati:
 For a = 0 To 99
   With clval1[a]
     Print .vB
     Print .vI
     Print .v$
   End With
 Next
 
End

Note

[1] Seguiremo in questo paragrafo, per quello che riguarda l'uso della parola chiave Property, quanto descritto in analoga discussione nel forum di Gambas-it.org l'utente sotema.