Questo articolo è tratto dal capitolo 4 (Programmazione orientata agli oggetti) del libro ASP.NET 2.0 per tutti di Daniele Bochicchio, Cristian Civera, Riccardo Golia e Stefano Mostarda.

Acquista la tua copia online!

L'articolo è la continuazione della prima parte pubblicata il 10 ottobre 2006.

Ereditarietà e polimorfismo

Le regole sintattiche utilizzate in C# e Visual Basic riguardanti l'ereditarietà e il polimorfismo sono molto diverse tra loro: ad uno stile molto compatto ed essenziale in C#, si contrappone uno stile molto verboso e ridondante in Visual Basic. Al di là di queste diversità sintattiche, i meccanismi e i concetti che stanno alla base dei due linguaggi sono del tutto equivalenti.

Sia in C# che in Visual Basic l'ereditarietà multipla non è contemplata. Per questo motivo una classe può derivare unicamente da una sola classe base. Questo aspetto non rappresenta tuttavia un vincolo di particolare rilievo: l'ereditarietà singola risulta essere decisamente sufficiente nella maggior parte dei casi.

In C# il legame di ereditarietà si indica con il carattere ":" (due-punti) posto subito dopo la dichiarazione della classe e seguito dal nome del tipo base. In Visual Basic il legame di ereditarietà tra due classi è indicato dalla parola chiave Inherits. Si noti che in Visual Basic il nome del tipo base va posto nella linea di codice successiva a quella della dichiarazione della classe derivata. L'esempio 4.9 mostra la dichiarazione della classe Employee che eredita dalla classe base Person.

' Employee deriva da Person
Public Class Employee
  Inherits Person
  ' ...
End Class

// Employee deriva da Person
public class Employee : Person
{
  // ...
}

I membri pubblici e protetti del tipo base sono accessibili anche nell'ambito delle classi derivate. Inoltre tutte le forme di visibilità, ovvero gli access modifier di ogni membro del tipo base, vengono ereditate a meno che esse non siano reimpostate diversamente nella classe derivata.

Nota
I membri statici, in quanto associati al tipo e non alle istanze, non vengono derivati, indipendentemente dal loro livello di accessibilità. Una classe definita come statica non può essere derivata.

Oltre alla keyword che identifica l'istanza corrente (this in C# e Me in Visual Basic), esiste una parola chiave che viene usata nelle classi derivate come riferimento al tipo base. In C# questa keyword è base, mentre in Visual Basic è MyBase. Questa parola chiave torna molto utile per richiamare in modo esplicito i metodi e, in generale, i membri pubblici o protetti del tipo base nei metodi e negli accessor delle proprietà di una classe derivata (esempio 4.10).

Public Class Employee
  Inherits Person
  
  Private _firstName As String

  Public Sub New()
    _firstName = MyBase.GetFirstName()
  End Sub

End Class

public class Employee : Person
{
  private string _firstName;
  
  // Viene richiamato implicitamente il costruttore
  // di default della classe base
  public Employee() : base()
  {
    _firstName = base.GetFirstName();
  }
}

A seconda di come viene dichiarata, una classe può non essere derivabile piuttosto che non essere istanziabile direttamente.

Una classe che non può essere derivata deve essere contrassegnata con la keyword sealed in C# e NotInheritable in Visual Basic (esempio 4.11).

' Customer deriva da Person e non può avere classi derivate
Public NotInheritable Class Customer
  Inherits Person

  ' ...  

End Class

// Customer deriva da Person e non può avere classi derivate
public sealed class Customer : Person
{
  // ...
}