abstract (Riferimenti per C#)
Il modificatore abstract può essere utilizzato insieme a classi, metodi, proprietà indicizzatori ed eventi. Utilizzare il modificatore abstract in una dichiarazione di classe per indicare che una classe può essere utilizzata soltanto come classe base di altre classi. I membri contrassegnati come astratti o inclusi in una classe astratta devono essere implementati da classi che derivano dalla classe astratta.
Nell'esempio riportato di seguito, la classe Square deve fornire un'implementazione di Area poiché deriva da ShapesClass:
abstract class ShapesClass
{
abstract public int Area();
}
class Square : ShapesClass
{
int x, y;
// Not providing an Area method results
// in a compile-time error.
public override int Area()
{
return x * y;
}
}
Per ulteriori informazioni sulle classi astratte, vedere Classi e membri delle classi astratte e sealed (Guida per programmatori C#).
Note
Le classi astratte presentano le caratteristiche descritte di seguito.
Non è possibile creare un'istanza di una classe astratta.
Una classe astratta può contenere metodi e funzioni di accesso astratti.
Non è possibile modificare una classe astratta con il modificatore sealed (Riferimenti per C#), il che significa che la classe non può essere ereditata.
Una classe non astratta derivata da una classe astratta deve includere le implementazioni effettive di tutti i metodi e le funzioni di accesso astratti ereditati.
Utilizzare il modificatore abstract nella dichiarazione di un metodo o di una proprietà per indicare che il metodo o la proprietà non contengono implementazioni.
I metodi astratti presentano le caratteristiche descritte di seguito.
Un metodo astratto è in modo implicito un metodo virtuale.
Le dichiarazioni dei metodi astratti possono essere utilizzate solo per le classi astratte.
Poiché la dichiarazione di un metodo astratto non fornisce alcuna implementazione effettiva, non esiste un corpo del metodo. La dichiarazione del metodo termina semplicemente con un punto e virgola e dopo la firma non sono presenti parentesi graffe ({ }). Di seguito è riportato un esempio:
public abstract void MyMethod();L'implementazione viene fornita da un metodo di overriding override (Riferimenti per C#), che è membro di una classe non astratta.
È errato utilizzare il modificatore static o virtual per la dichiarazione di un metodo astratto.
Le proprietà astratte hanno un comportamento analogo a quello dei metodi astratti, ma presentano delle differenze nella sintassi della dichiarazione e delle chiamate.
È errato utilizzare il modificatore abstract su una proprietà statica.
È possibile sottoporre a override una proprietà astratta ereditata in una classe derivata includendo una dichiarazione di proprietà che utilizza il modificatore override.
Una classe astratta deve fornire l'implementazione per tutti i membri di interfaccia.
La classe astratta che implementa un'interfaccia può associare i metodi di interfaccia a metodi astratti. Di seguito è riportato un esempio:
interface I
{
void M();
}
abstract class C: I
{
public abstract void M();
}
Esempio
In questo esempio la classe DerivedClass deriva da una classe astratta BaseClass. La classe astratta contiene il metodo astratto AbstractMethod e le due proprietà astratte X e Y.
// abstract_keyword.cs
// Abstract Classes
using System;
abstract class BaseClass // Abstract class
{
protected int _x = 100;
protected int _y = 150;
public abstract void AbstractMethod(); // Abstract method
public abstract int X { get; }
public abstract int Y { get; }
}
class DerivedClass : BaseClass
{
public override void AbstractMethod()
{
_x++;
_y++;
}
public override int X // overriding property
{
get
{
return _x + 10;
}
}
public override int Y // overriding property
{
get
{
return _y + 10;
}
}
static void Main()
{
DerivedClass o = new DerivedClass();
o.AbstractMethod();
Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
}
}
Output
x = 111, y = 161
Commenti
Nell'esempio precedente, se si tenta di creare un'istanza per la classe astratta tramite una dichiarazione di questo tipo:
BaseClass bc = new BaseClass(); // Error
si otterrà un errore che indica che il compilatore non può creare un'istanza della classe astratta 'BaseClass'.
Specifiche del linguaggio C#
Per ulteriori informazioni, vedere le sezioni riportate di seguito in Specifiche del linguaggio C#:
1.6.5.4 Metodi virtuali, di override e astratti
10.1.1.1 Classi astratte
Vedere anche
Riferimenti
Modificatori (Riferimenti per C#)
virtual (Riferimenti per C#)
override (Riferimenti per C#)
Parole chiave di C#