|
Eccoci arrivati a parlare degli aspetti peculiari di un linguaggio ad oggetti! Iniziamo con l'Edereditarietà.
L'ereditarietà è la possibilità di un linguaggio ad oggetti di far derivare una classe da un'altra: in questo caso,
la prima assume il nome di classe derivata, mentre la seconda quello di classe base. La classe derivata
acquisisce tutti i membri della classe base, ma può ridefinirli o aggiungerne di nuovi. Questa caratteristica di ogni
linguaggio Object Oriented è particolarmente efficace nello schematizzare una relazione "is-a" (ossia "è un"). Per esempio, potremmo
definire una classe Vegetale, quindi una nuova classe Fiore, che eredita Vegetale. Fiore è un Vegetale, come mostra la struttura gerarchica
dell'ereditarietà. Se definissimo un'altra classe Primula, derivata da Fiore, diremmo che Primula è un Fiore, che a sua volta è un
Vegetale. Quest'ultimo tipo di relazione, che crea classi derivate che saranno basi per ereditare altre classi, si chiama ereditarietà
indiretta.
Passiamo ora a vedere come si dichiara una classe derivata:
Class [Nome]
Inherits [Classe base]
'Membri della classe
End Class
La keyword Inherits specifica quale classe base ereditare: si può avere solo UNA direttiva Inherits per classe, ossia non è possibile
ereditare più classi base. In questo frangente, si può scoprire come le proprietà siano utili e flessibili: se una classe base definisce
una variabile pubblica, questa diverrà parte anche della classe derivata e su tale variabile verranno basate tutte le operazioni che la
coinvolgono. Siccome è possibile che la classe derivata voglia ridefinire tali operazioni e molto probabilmente anche l'utilizzo della
variabile, è sempre consigliabile dichiarare campi Private avvolti da una proprietà, poichè non c'è mai alcun pericolo nel modificare
una proprietà in classi derivate, ma non è possibile modificare i campi nella stessa classe. Un semplice esempio di ereditarietà:
Class Person
'Per velocizzare la scrittura del codice, assumiamo che
'questi campi pubblici siano proprietà
Public FirstName, LastName As String
Public ReadOnly Property CompleteName() As String
Get
Return FirstName & " " & LastName
End Get
End Property
End Class
'Lo studente, ovviamente, è una persona
Class Student
'Student eredita da Person
Inherits Person
'In più, definisce anche questi campi pubblici
'La scuola frequentata
Public School As String
'E l'anno di corso
Public Grade As Byte
End Class
In seguito, si può utilizzare la classe derivata come si è sempre fatto con ogni altra classe. Nel farne uso, tuttavia,
è necessario considerare che una classe derivata possiede non solo i membri che il programmatore ha esplicitamente definito nel suo
corpo, ma anche tutti quei membri presenti nella classe base che si sono implicitamente acquisiti nell'atto stesso di scrivere "Inherits".
Se vogliamo, possiamo assimilare una classe ad un insieme, i cui elementi sono i suoi membri: una classe base è sottoinsieme della
corrispondente classe derivata. Di solito, l'ambiente di sviluppo aiuta molto in questo, poiché, nei suggerimenti proposti durante
la scrittura del codice, vengono automaticamente inserite anche le voci ereditate da altre classi. Ciò che abbiamo appena visto
vale anche per ereditarietà indiretta: se A eredita da B e B eredita da C, A disporrà dei membri di B, alcuni dei quali sono
anche membri di C (semplice proprietà transitiva).
Ora, però, bisogna porre un bel Nota Bene alla questione. Infatti, non tutto è semplice come sembra. Forse nessuno si è
chiesto che fine fanno gli specificatori di accesso quando un membro viene ereditato da una classe derivata. Ebbene, esistono delle precise
regole che indicano come gli scope vengono trattati quando si eredita:
- Un membro Public o Friend della classe base diventa un membro Public o Friend della classe derivata (in pratica, non cambia
nulla; viene ereditato esattamente com'è);
- Un membro Private della classe base non è accessibile dalla classe derivata, poichè il suo ambito di visibilità impedisce a ogni
chiamante esterno alla classe base di farvi riferimento, come già visto nelle lezioni precedenti;
- Un membro Protected della classe base diventa un membro Protected della classe derivata, ma si comporta come un membro Private.
Ed ecco che abbiamo introdotto uno degli specificatori che ci eravamo lasciati indietro. I membri Protected sono particolarmente utili
e costituiscono una sorta di "scappatoia" al fatto che quelli privati non subiscono l'ereditarietà. Infatti, un memebro Protected si
comporta esattamente come uno Private, con un'unica eccezione: è ereditabile, ed in questo caso diventa un membro Protected della
classe derivata. Lo stesso discorso vale anche per Protected Friend. Ecco uno schema che esemplifica il comportamento dei principali Scope:
Esempio:
Module Esempio
Class Person
'Due campi protected
Protected _FirstName, _LastName As String
'Un campo private readonly: non c'è ragione di rendere
'questo campo Protected poichè la data di nascita non
'cambia ed è sempre accessibile tramite la proprietà
'pubblica BirthDay
Private ReadOnly _BirthDay As Date
Public Property FirstName() As String
Get
Return _FirstName
End Get
Set(ByVal Value As String)
If Value <> "" Then
_FirstName = Value
End If
End Set
End Property
Public Property LastName() As String
Get
Return _LastName
End Get
Set(ByVal Value As String)
If Value <> "" Then
_LastName = Value
End If
End Set
End Property
Public ReadOnly Property BirthDay() As Date
Get
Return _BirthDay
End Get
End Property
Public ReadOnly Property CompleteName() As String
Get
Return _FirstName & " " & _LastName
End Get
End Property
'Costruttore che accetta tra parametri obbligatori
Sub New(ByVal FirstName As String, ByVal LastName As String, _
ByVal BirthDay As Date)
Me.FirstName = FirstName
Me.LastName = LastName
Me._BirthDay = BirthDay
End Sub
End Class
'Lo studente, ovviamente, è una persona
Class Student
'Student eredita da Person
Inherits Person
'La scuola frequentata
Private _School As String
'E l'anno di corso
Private _Grade As Byte
Public Property School() As String
Get
Return _School
End Get
Set(ByVal Value As String)
If Value <> "" Then
_School = Value
End If
End Set
End Property
Public Property Grade() As Byte
Get
Return _Grade
End Get
Set(ByVal Value As Byte)
If Value > 0 Then
_Grade = Value
End If
End Set
End Property
'Questa nuova proprietà si serve anche dei campi FirstName
'e LastName nel modo corretto, poichè sono Protected anche
'nella classe derivata e fornisce un profilo completo
'dello studente
Public ReadOnly Property Profile() As String
Get
'Da notare l'accesso a BirthDay tramite la proprietà
'Public: non è possibile accedere al campo _BirthDay
'perchè è privato nella classe base
Return _FirstName & " " & _LastName & ", nato il " & _
BirthDay.ToShortDateString & " frequenta l'anno " & _
_Grade & " alla scuola " & _School
End Get
End Property
'Altra clausola importante: il costruttore della classe
'derivata deve sempre richiamare il costruttore della
'classe base
Sub New(ByVal FirstName As String, ByVal LastName As String, _
ByVal BirthDay As Date, ByVal School As String, _
ByVal Grade As Byte)
MyBase.New(FirstName, LastName, BirthDay)
Me.School = School
Me.Grade = Grade
End Sub
End Class
Sub Main()
Dim P As New Person("Pinco", "Pallino", Date.Parse("06/07/90"))
Dim S As New Student("Tizio", "Caio", Date.Parse("23/05/92"), _
"Liceo Classico Ugo Foscolo", 2)
Console.WriteLine(P.CompleteName)
'Come si vede, la classe derivata gode degli stessi membri
'di quella base, acquisiti secondo le regole
'dell'ereditarietà appena spiegate
Console.WriteLine(S.CompleteName)
'E in più ha anche i suoi nuovi membri
Console.WriteLine(S.Profile)
'Altra cosa interessante: dato che Student è derivata da
'Person ed espone tutti i membri di Person, più altri,
'non è sbagliato assegnare un oggetto Student a una
'variabile Person
P = S
Console.WriteLine(P.CompleteName)
Console.ReadKey()
End Sub
End Module
L'output:
Pinco Pallino
Tizio Caio
Tizio Caio, nato il 23/5/1992 frequenta l'anno 2 alla scuola Liceo Classico Ugo
Foscolo
Tizio Caio
(Per maggiori informazioni sulle operazioni con le date, vedere il capitolo 57)
Anche se il sorgente è ampiamente commentato mi soffermerei su alcuni punti caldi. Il costruttore della classe derivata deve sempre
richiamare il costruttore della classe base, e questo avviene tramite la keyword MyBase che, usata in una classe derivata, fa riferimento alla
classe base corrente: attraverso questa parola riservata è possibile anche raggiungere i membri privati della classe base, ma si fa
raramente, poichè il suo impiego più frequente è quello di riprendere le vecchie versioni di metodi modificati. Il secondo punto riguarda
la conversione di classi: passare da Student a Person non è, come potrebbe sembrare, una conversione di riduzione, poichè durante il
processo, nulla va perduto nel vero senso della parola. Certo, si perdono le informazioni supplementari, ma alla classe base queste non servono:
la sicurezza di eseguire la conversione risiede nel fatto che la classe derivata gode degli stessi membri di quella base e quindi non si
corre il rischio che ci sia riferimento a un membro inesistente. Questo invece si verifica nel caso opposto: se una variabile di tipo Student
assumesse il valore di un oggetto Person, School e Grade sarebbero privi di valore e ciò generebbe un errore. Per eseguire questo tipo di
passaggi è necessario l'operatore DirectCast.
|
|
Feeds
Sondaggio
Condividi
Numeri
