Una classe che non può essere direttamente istanziata e che quindi deve essere obbligatoriamente derivata si dice astratta. Per dichiarare una classe astratta occorre specificare la parola chiave abstract in C# e MustInherit in Visual Basic. Le classi astratte sono caratterizzate dal fatto di avere tutti i metodi e le proprietà o un loro sottoinsieme definiti anch'essi come astratti.
Un membro astratto è un elemento della classe per il quale viene riportata semplicemente la dichiarazione insieme alla parola chiave specifica che in C# è sempre abstract, mentre in Visual Basic è MustOverride (esempio 4.12). In nessun caso viene specificata l'implementazione.
' Person è una classe astratta e deve essere derivata
Public MustInherit Class Person
' Metodo astratto
Public MustOverride Function GetFirstName() As String
' Proprietà astratta
Public MustOverride Property FullName As String
Get
Set(ByVal value As String)
End Property
End Class
// Person è una classe astratta e deve essere derivata
public abstract class Person
{
// Metodo astratto
public abstract GetFirstName();
// Proprietà astratta
public abstract string FullName { get; set; }
}
Come si è avuto modo di dire nella prima parte del capitolo, il polimorfismo rappresenta la possibilità di ridefinire le proprietà e i metodi nelle classi derivate rispetto a quelli dichiarati nel tipo base (override). Affinché possa essere polimorfico, un membro deve essere marcato come astratto oppure come virtuale.
Dato che per un membro astratto nell'ambito del tipo base è presente unicamente la sua dichiarazione, è chiaro che esso debba essere implementato ogni volta in ciascuna delle classi derivate. Questo implica che ogni classe derivata è caratterizzata da comportamenti simili che devono peraltro adottare necessariamente strategie implementative diverse.
A differenza di quanto succede per i membri astratti, nel caso dei membri virtuali esiste sempre nella superclasse un'implementazione di base. Peraltro un membro virtuale può essere ridefinito in modo personalizzato nelle classi derivate. Questo significa che, oltre all'implementazione di base, possono esistere implementazioni diverse dello stesso membro, ciascuna delle quali afferenti ad una diversa classe derivata.
Se per proprietà e metodi astratti è sempre obbligatorio definire un'implementazione nella classe derivata, questo non è vero per i membri virtuali: nel caso in cui un membro virtuale non venga ridefinito nel tipo derivato, rimane valida la versione presente nella superclasse.
Nota
I campi di una classe non possono essere soggetti a override, né definiti come astratti (del resto contengono solamente dati, non definiscono comportamenti). Gli unici membri che possono essere polimorfici sono i metodi e le proprietà.
La keyword che permette di contrassegnare un membro come virtuale è virtual in C# e Overridable in Visual Basic (esempio 4.13). Per eseguire l'override di un membro nell'ambito di una classe derivata, occorre specificare la parola chiave override in C# e Overrides in Visual Basic (esempio 4.13). Per indicare che un membro non può essere ulteriormente soggetto a override nelle classi derivate, occorre invece specificare la keyword sealed in C# e NotOverridable in Visual Basic.
Nota
La parola chiave new in C# e la keyword Shadows in Visual Basic permettono di nascondere in modo esplicito un membro ereditato da una classe base. Questo significa che la versione derivata del membro sostituisce la versione della classe base. Lo scopo principale dello shadowing è infatti quello di proteggere la definizione dei membri di una classe. Se nel tipo base viene aggiunto un nuovo elemento con il nome uguale a quello del membro già definito nella classe derivata, le keyword new e Shadows impongono che i riferimenti attraverso la classe vengano comunque risolti nel membro della classe derivata, anziché nel nuovo elemento della superclasse.
È sempre bene ricordare che un membro virtuale viene risolto in base al tipo dell'istanza su cui viene richiamato, non in funzione del tipo del riferimento. L'esempio 4.13 illustra questo importante concetto, mostrando una casistica significativa di invocazione di un metodo virtuale.
Public Class Person
' Metodo virtuale
Public Overridable Function GetFirstName() As String
' Implementazione di base del metodo
End Function
End Class
Public Class Employee
Inherits Person
Public Overrides Function GetFirstName() As String
' Nuova implementazione del metodo
End Function
End Class
Dim empl As New Employee() ' Istanza di Employee
Dim pers As Person ' Viene comunque eseguito il
Dim name As String ' metodo di Employee anche se
pers = empl ' il riferimento è di tipo Person
name = pers.GetFirstName()
public class Person
{
// Metodo virtuale
public virtual string GetFirstName()
{
// Implementazione di base del metodo
}
}
public class Employee : Person
{
public override string GetFirstName()
{
// Nuova implementazione del metodo
}
}
Employee empl = new Employee(); // Istanza di Employee
Person pers = empl; // Viene eseguito il
string name = pers.GetFirstName(); // metodo di Employee
Contenuti dell'articolo
- Pagina 1
- Pagina 3
- Pagina 4
- Pagina 5
- Galleria fotografica dinamica con ASP.NET AJAX
- Usare Search come un servizio nei tuoi siti e nei tuoi client
- Mappe nel tuo sito con Virtual Earth
- Integrare Windows Live ID, Contacts e Presence API nelle tue applicazioni
- Introduzione ai cloud based service con Windows Live Services
- Realizzare un custom extender AJAX con ASP.NET 3.5
- Tracciare le modifiche ai dati e allineare i datawarehouse con il Change Data Capture in SQL Server 2008
- Le nuove caratteristiche di IIS 7.0 per sviluppatori e sistemisti
Aggiungi un nuovo commento »»»
Per inserire un commento, devi registrarti alla nostra community.
Difficoltà
Stampa 
Download 
10annidi.ASPItalia.com: iscriviti alla competizione e vinci fantastici premi ogni mese!