Interfacce
Una interfaccia è un tipo simile ad una classe astratta pura, ossia composta solamente da metodi e da proprietà astratte. Essa è infatti priva di qualsiasi implementazione, dato che il suo scopo è semplicemente quello di definire un contratto valido per le classi che la vanno ad implementare.
Il grosso vantaggio nell'utilizzo delle interfacce è rappresentato dal fatto che una classe può implementare più di un'interfaccia contemporaneamente. Questo aspetto va a compensare almeno parzialmente la mancanza dell'ereditarietà multipla per le classi.
Un'interfaccia viene definita specificando la parola chiave interface in C# e Interface in Visual Basic seguita dal nome identificativo. Non occorre specificare gli access modifier per i suoi elementi, ma per ognuno è sufficiente inserire la dichiarazione, omettendo qualsiasi forma di implementazione (esempio 4.14). In un'interfaccia possono essere incluse dichiarazioni di metodi, proprietà ed eventi.
' Interfaccia che definisce un metodo per la stampa
Public Interface IPrintable
Sub Print() ' Metodo dell'interfaccia
End Class
// Interfaccia che definisce un metodo per la stampa
public interface IPrintable
{
void Print(); // Metodo dell'interfaccia
}
L'implementazione di un'interfaccia in C# segue le stesse regole sintattiche utilizzate nel caso dell'ereditarietà. In Visual Basic la sintassi è invece completamente diversa rispetto alla derivazione. Come è possibile vedere nell'esempio 4.15, la parola chiave da specificare è Implements ed essa va utilizzata sia nella dichiarazione del tipo (su una linea di codice dedicata), sia per ogni elemento dell'interfaccia che viene implementato nella classe (sulla stessa linea della dichiarazione del membro).
Nota
Nel caso di implementazione multipla, si usa il carattere "," (virgola) per separare tra loro le diverse interfacce associate alla classe. In C# il tipo base e le interfacce implementate vengono indicate nello stesso elenco.
Oltre alla dichiarazione, l'esempio 4.15 riporta anche una casistica di utilizzo. Ogni istanza relativa ad una classe che implementa un'interfaccia può essere assegnata ad una variabile dell'interfaccia stessa. In questo caso i membri che possono essere richiamati sono solamente quelli associati all'interfaccia e non quelli esposti dalla classe che implementa l'interfaccia (per poterli invocare occorre necessariamente fare una cast al tipo).
Public Class Employee
Inherits Person
Implements IPrintable
Public Sub Print() Implements IPrintable.Print
' ...
End Sub
End Class
Dim p as IPrintable
Dim empl As New Employee()
p = empl
p.Print()
Dim x As String = p.GetFirstName() ' È necessario il cast
Dim y As String = DirectCast(Employee, p).GetFirstName() ' OK
public class Employee : Person, IPrintable
{
public void Print()
{
// ...
}
}
IPrintable p = new Employee();
p.Print();
string x = p.GetFirstName(); // È necessario il cast
string x = (Employee)p.GetFirstName(); // OK
A questo punto sorge spontanea una domanda: quando usare le interfacce e quando invece utilizzare le classi astratte pure?
È stato detto che entrambe definiscono un contratto per le classi a cui sono associate, dato che internamente non contengono implementazioni, ma solo dichiarazioni. Peraltro le classi astratte pure forniscono un tipo di contratto "più forte", in quanto, oltre a definire i comportamenti per le classi associate, esse ne rappresentano anche il tipo base.
Diversamente le interfacce permettono una maggiore flessibilità, in quanto sono tipi indipendenti e trasversali rispetto alla gerarchia delle classi definita tramite i legami di ereditarietà. L'uso delle interfacce è quindi da preferire nel caso in cui si vogliano definire contratti di natura generale che possano essere usati indipendentemente dai legami di ereditarietà e che non impongano comportamenti specifici e di valenza esclusiva.
Contenuti dell'articolo
- Pagina 1
- Pagina 3
- Pagina 4
- Pagina 5
Aggiungi un nuovo commento »»»
Per inserire un commento, devi registrarti alla nostra community.
Difficoltà
Stampa 
Download 
