Esporta (0) Stampa
Espandi tutto

abstract (Riferimenti per C#)

Aggiornamento: novembre 2007

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 side = 0;

    public Square(int n)
    {
        side = n;
    }
    // Area method is required to avoid
    // a compile-time error.
    public override int Area()
    {
        return side * side;
    }

    static void Main() 
    {
        Square sq = new Square(12);
        Console.WriteLine("Area of the square = {0}", sq.Area());
    }

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

}
// Output: Area of the square = 144


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#) perché sealed impedisce l'ereditarietà della classe.

  • 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 overridingoverride (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.

Per ulteriori informazioni sulle classi astratte, vedere Classi e membri delle classi astratte e sealed (Guida per programmatori C#).

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();
}


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 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



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'.

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft