abstract (C#-Referenz)

Der abstract-Modifizierer gibt an, dass dem modifizierten Objekt eine Implementierung fehlt oder dass diese unvollständig ist. Der abstract-Modifizierer kann für Klassen, Methoden, Eigenschaften, Indexer und Ereignisse verwendet werden. Verwenden Sie den abstract-Modifizierer in einer Klassendeklaration, um anzugeben, dass die Klasse nur die Basisklasse für andere Klassen sein und nicht selbst instanziiert werden soll. Als abstrakt markierte Member müssen von Klassen, die von nicht abstrakten Klassen abgeleitet wurden, implementiert werden.

Beispiel 1

In diesem Beispiel muss die Klasse Square eine Implementierung von GetArea bereitstellen, da sie von Shape abgeleitet ist:

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

Abstrakte Klassen weisen die folgenden Funktionen auf:

• Eine abstrakte Klasse darf nicht instanziiert werden.

• Eine abstrakte Klasse enthält möglicherweise abstrakte Methode und Accessoren.

• Eine abstrakte Klasse kann nicht mit dem sealed-Modifizierer geändert werden, da sich die beiden Modifizierer gegenseitig ausschließen. Der sealed-Modifizierer verhindert das Vererben einer Klasse, und der abstract-Modifizierer erfordert das Vererben einer Klasse.

• Eine nicht abstrakte Klasse, die von einer abstrakten Klasse abgeleitet wurde, muss Implementierungen aller geerbten abstrakten Methoden und Accessoren enthalten.

Verwenden Sie den abstract-Modifizierer in einer Methoden- oder Eigenschaftendeklaration, um anzugeben, dass die Methode oder Eigenschaft keine Implementierung enthalten.

Abstrakte Methoden weisen die folgenden Funktionen auf:

• Eine abstrakte Methode ist implizit eine virtuelle Methode.

• Abstrakte Methodendeklarationen sind nur in abstrakten Klassen zulässig.

• Es gibt keinen Methodenkörper, da eine abstrakte Methodendeklaration keine Implementierungen bietet; die Methodendeklaration enden ganz einfach mit einem Semikolon; auf die Signatur folgen keine geschweiften Klammern ({ }). Beispiel:

  public abstract void MyMethod();  
  

  Die Implementierung wird von der Methode override zur Verfügung gestellt, die ein Member einer nicht abstrakten Klasse ist.

• Es ist unzulässig, die Modifizierer static oder virtual in einer abstrakten Methodendeklaration zu verwenden.

Abstrakte Eigenschaften verhalten sich wie abstrakte Methoden – sie unterscheiden sich lediglich in der Deklarations- und Aufrufsyntax.

• Es ist ein unzulässig, den abstract-Modifizierer für eine statische Eigenschaft zu verwenden.

• Eine abstrakte vererbte Eigenschaft kann in einer abgeleiteten Klasse mithilfe der Eigenschaftendeklaration, die den Modifizierer override verwendet, außer Kraft gesetzt werden.

Weitere Informationen zu abstrakten Klassen finden Sie unter Abstrakte und versiegelte Klassen und Klassenmember.

Eine abstrakte Klasse muss eine Implementierung für alle Schnittstellenmember bereitstellen.

Eine abstrakte Klasse, die eine Schnittstelle implementiert, ordnet die Schnittstellenmethoden möglicherweise abstrakten Methoden zu. Beispiel:

interface I
{
    void M();
}

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

Beispiel 2

In diesem Beispiel wird die DerivedClass-Klasse von der abstrakten Klasse BaseClass abgeleitet. Die abstrakte Klasse enthält eine abstrakte Methode, AbstractMethod, und zwei abstrakte Eigenschaften, X und 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

Wenn Sie beim vorherigen Beispiel versuchen, die abstrakte Klasse mithilfe des folgenden Anweisungsbeispiels zu instanziieren:

BaseClass bc = new BaseClass();   // Error  

Sie erhalten eine Fehlermeldung, dass der Compiler keine Instanz der abstrakten Klasse „BaseClass“ erstellen kann.

Dennoch ist es möglich, einen abstrakten Klassenkonstruktor wie im folgenden Beispiel zu verwenden.

Beispiel 3

public abstract class Shape
{
    public string Color { get; set; }

    // Constructor of the abstract class
    protected Shape(string color)
    {
        Color = color;
        Console.WriteLine("Created a shape with color {color}.");
    }

    // Abstract method that must be implemented by derived classes
    public abstract double CalculateArea();
}

public class Square : Shape
{
    public double Side { get; set; }

    // Constructor of the derived class calling the base class constructor
    public Square(string color, double side) : base(color)
    {
        Side = side;
    }

    public override double CalculateArea()
    {
        return Side * Side;
    }
}

public class Program
{
    public static void Main(string[] args)
     {
            Square square = new Square("red", 5);
            Console.WriteLine("Area of the square: {square.CalculateArea()}");            
     }
}

Die Shape Klasse wird abstractdeklariert, was bedeutet, dass sie nicht direkt instanziiert werden kann. Stattdessen dient sie als Blaupause für andere Klassen.

• Obwohl Sie keine Objekte einer abstrakten Klasse erstellen können, kann sie dennoch über einen Konstruktor verfügen. Dieser Konstruktor ist in der Regel protected, d. h. er kann nur von abgeleiteten Klassen aufgerufen werden. In diesem Fall verwendet der Shape-Konstruktor einen color-Parameter und initialisiert die Color-Eigenschaft. Außerdem wird eine Meldung auf der Konsole ausgegeben. Der public Square(string color, double side) : base(color)-Teil ruft den Konstruktor der Basisklasse (Shape) auf und übergibt das Argument color an ihn.
• In der Shape-Klasse akzeptiert der definierte Konstruktor eine Farbe als Parameter protected Shape(string color). Dies bedeutet, dass es keinen standardmäßigen parameterlosen Konstruktor mehr gibt, der von C# automatisch bereitgestellt wird, damit abgeleitete Klassen den : base(color) Ausdruck verwenden müssen, um den Basiskonstruktor aufzurufen. Wenn der Standardwert auf die Farbe protected Shape(string color="green") gesetzt wird, kann der Ausdruck : base(color) in abgeleiteten Klassen weggelassen werden. Dennoch wird der Konstruktor protected Shape(string color="green") aufgerufen und die Farbe auf Grün gesetzt.

C#-Programmiersprachenspezifikation

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auch

• virtual
• override
• C#-Schlüsselwörter