Condividi tramite

abstract (Riferimenti per C#)

  • Articolo

Il modificatore abstract indica che l'oggetto in fase di modifica ha un'implementazione mancante o incompleta. Il modificatore abstract può essere usato con classi, metodi, proprietà, indicizzatori ed eventi. Usare il modificatore abstract in una dichiarazione di classe per indicare che una classe verrà usata solo come classe di base per altre classi e che non verrà creata un'istanza relativamente alla stessa. I membri contrassegnati come astratti devono essere implementati da classi non astratte che derivano dalla classe astratta.

Esempio 1

In questo esempio, la classe Square deve eseguire un'implementazione di GetArea poiché deriva da Shape:

abstract class Shape
{
    public abstract int GetArea();
}

class Square : Shape
{
    private int _side;

    public Square(int n) => _side = n;

    // GetArea method is required to avoid a compile-time error.
    public override int GetArea() => _side * _side;

    static void Main()
    {
        var sq = new Square(12);
        Console.WriteLine($"Area of the square = {sq.GetArea()}");
    }
}
// Output: Area of the square = 144

Le classi astratte hanno le caratteristiche seguenti:

  • Non è possibile creare un'istanza di una classe astratta.

  • Una classe astratta può contenere funzioni di accesso e metodi astratti.

  • Non è possibile modificare una classe astratta con il modificatore sealed perché i due modificatori hanno significati opposti. Il modificatore sealed impedisce a una classe che venga ereditata e il modificatore abstract richiede una classe da ereditare.

  • Una classe non astratta derivata da una classe astratta deve includere implementazioni effettive di tutte le funzioni di accesso e di tutti i metodi astratti ereditati.

Usare il modificatore abstract in una dichiarazione di metodo o proprietà per indicare che il metodo o proprietà non contiene implementazioni.

I metodi astratti hanno le caratteristiche seguenti:

  • Un metodo astratto è implicitamente un metodo virtuale.

  • Le dichiarazioni di metodi astratti sono consentite solo in classi astratte.

  • Poiché una dichiarazione di un metodo astratto non offre alcuna implementazione effettiva, non c'è nessun corpo del metodo. La dichiarazione del metodo termina semplicemente con un punto e virgola e non ci sono parentesi graffe ({ }) dopo la firma. Ad esempio:

    public abstract void MyMethod();

    L'implementazione viene specificata tramite l'override di un metodo, che è un membro di una classe non astratta.

  • Non è possibile usare il modificatore static o virtual in una dichiarazione di un metodo astratto.

Le proprietà astratte si comportano come i metodi astratti, ad eccezione delle differenze nella sintassi di dichiarazione e di chiamata.

  • Non è possibile usare il modificatore abstract su una proprietà static.

  • Una proprietà astratta ereditata può essere sottoposta a override in una classe derivata includendo una dichiarazione di proprietà che usa il modificatore di override.

Per altre informazioni sulle classi astratte, vedere Classi e membri delle classi astratte e sealed.

Una classe astratta deve specificare l'implementazione per tutti i membri di interfaccia.

Una classe astratta che implementa un'interfaccia può eseguire il mapping dei metodi di interfaccia su metodi astratti. Ad esempio:

interface I
{
    void M();
}

abstract class C : I
{
    public abstract void M();
}

Esempio 2

In questo esempio, la classe DerivedClass è derivata da una classe di base astratta BaseClass. La classe astratta contiene un metodo astratto, AbstractMethod, e due proprietà astratte, X e Y.

// Abstract class
abstract class BaseClass
{
    protected int _x = 100;
    protected int _y = 150;

    // Abstract method
    public abstract void AbstractMethod();

    // Abstract properties
    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()
    {
        var o = new DerivedClass();
        o.AbstractMethod();
        Console.WriteLine($"x = {o.X}, y = {o.Y}");
    }
}
// Output: x = 111, y = 161

Nell'esempio precedente, se si prova a creare un'istanza della classe astratta tramite un'istruzione simile alla seguente:

BaseClass bc = new BaseClass();   // Error

si ottiene un messaggio di errore che informa che il compilatore non può creare un'istanza della classe astratta "BaseClass".

Specifiche del linguaggio C#

Per altre informazioni, vedere la specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedi anche