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.

Het is echter mogelijk om een abstracte klasseconstructor te gebruiken, zoals in het onderstaande voorbeeld

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

De Shape klasse wordt gedeclareerd abstract, wat betekent dat deze niet rechtstreeks kan worden geïnstantieerd. In plaats daarvan fungeert het als blauwdruk voor andere klassen.

  • Hoewel u geen objecten van een abstracte klasse kunt maken, kan deze nog steeds een constructor hebben. Deze constructor is doorgaans protected, wat betekent dat deze alleen toegankelijk is vanuit afgeleide klassen. In dit geval neemt de Shape constructor een color parameter en initialiseert de eigenschap Color. Er wordt ook een bericht naar de console afgedrukt. Het public Square(string color, double side) : base(color) onderdeel roept de constructor van de basisklasse (Shape) aan en geeft het argument color door.
  • In de klasse Shape heeft de gedefinieerde constructor een kleur als parameter protected Shape(string color). Dit betekent dat er geen standaardparameterloze constructor meer automatisch wordt geleverd door C# en dat afgeleide klassen de : base(color)-expressie moeten gebruiken om de basisconstructor aan te roepen. Als u de standaardwaarde instelt op kleur protected Shape(string color="green") kunt u de : base(color)-expressie weglaten in afgeleide klassen. Nog steeds wordt een dergelijke constructor-protected Shape(string color="green") aangeroepen, waarbij de kleur groen wordt ingesteld.

C#-taalspecificatie

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

Zie ook