Delen via

abstract (C#-verwijzing)

  • Artikel

De abstract wijzigingsfunctie geeft aan dat het te wijzigen ding een ontbrekende of onvolledige implementatie heeft. De abstracte wijziging kan worden gebruikt met klassen, methoden, eigenschappen, indexeerfuncties en gebeurtenissen. Gebruik de abstract wijzigingsfunctie in een klassedeclaratie om aan te geven dat een klasse alleen bedoeld is als basisklasse van andere klassen, niet zelfstandig geïnstantieerd. Leden die als abstract zijn gemarkeerd, moeten worden geïmplementeerd door niet-abstracte klassen die zijn afgeleid van de abstracte klasse.

Voorbeeld 1

In dit voorbeeld moet de klasse Square een implementatie GetArea opgeven, omdat deze is afgeleid van 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

Abstracte klassen hebben de volgende functies:

  • Een abstracte klasse kan niet worden geïnstantieerd.

  • Een abstracte klasse kan abstracte methoden en accessors bevatten.

  • Het is niet mogelijk om een abstracte klasse te wijzigen met de verzegelde modifier, omdat de twee modifiers tegengestelde betekenissen hebben. De sealed wijzigingsfunctie voorkomt dat een klasse wordt overgenomen en de abstract wijzigingsfunctie vereist dat een klasse wordt overgenomen.

  • Een niet-abstracte klasse die is afgeleid van een abstracte klasse moet werkelijke implementaties van alle overgenomen abstracte methoden en accessors bevatten.

Gebruik de abstract wijzigingsfunctie in een methode- of eigenschapsdeclaratie om aan te geven dat de methode of eigenschap geen implementatie bevat.

Abstracte methoden hebben de volgende functies:

  • Een abstracte methode is impliciet een virtuele methode.

  • Abstracte methodedeclaraties zijn alleen toegestaan in abstracte klassen.

  • Omdat een abstracte methodedeclaratie geen werkelijke implementatie biedt, is er geen hoofdtekst van de methode; de methodedeclaratie eindigt gewoon met een puntkomma en er zijn geen accolades ({ }) na de handtekening. Voorbeeld:

    public abstract void MyMethod();

    De implementatie wordt geleverd door een methode die lid is van een niet-abstracte klasse.

  • Het is een fout bij het gebruik van de statische of virtuele modifiers in een abstracte methodedeclaratie.

Abstracte eigenschappen gedragen zich als abstracte methoden, met uitzondering van de verschillen in declaratie- en aanroepsyntaxis.

  • Het is een fout bij het gebruik van de abstract wijzigingsfunctie voor een statische eigenschap.

  • Een abstracte overgenomen eigenschap kan worden overschreven in een afgeleide klasse door een eigenschapsdeclaratie op te nemen die gebruikmaakt van de wijzigingsaanpassing voor onderdrukking.

Zie Abstracte en Verzegelde klassen en Klasseleden voor meer informatie over abstracte klassen.

Een abstracte klasse moet implementatie bieden voor alle interfaceleden.

Een abstracte klasse die een interface implementeert, kan de interfacemethoden toewijzen aan abstracte methoden. Voorbeeld:

interface I
{
    void M();
}

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

Voorbeeld 2

In dit voorbeeld is de klasse DerivedClass afgeleid van een abstracte klasse BaseClass. De abstracte klasse bevat een abstracte methode, AbstractMethoden twee abstracte eigenschappen, X en 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

Als u in het voorgaande voorbeeld probeert een instantie van de abstracte klasse te maken met behulp van een instructie als volgt:

BaseClass bc = new BaseClass();   // Error

Er wordt een foutbericht weergegeven waarin wordt aangegeven dat de compiler geen exemplaar van de abstracte klasse BaseClass kan maken.

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Zie ook