abstract (odwołanie w C#)

Artykuł
16.01.2025

Modyfikator abstract wskazuje, że element, który jest modyfikowany, ma brak lub niekompletną implementację. Modyfikator abstrakcyjny może być używany z klasami, metodami, właściwościami, indeksatorami i zdarzeniami. abstract Użyj modyfikatora w deklaracji klasy, aby wskazać, że klasa ma być klasą bazową innych klas, a nie tworzone samodzielnie. Elementy członkowskie oznaczone jako abstrakcyjne muszą być implementowane przez klasy nie abstrakcyjne, które pochodzą z klasy abstrakcyjnej.

Przykład 1

W tym przykładzie klasa Square musi dostarczyć implementację elementu GetArea , ponieważ pochodzi z klasy 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

Klasy abstrakcyjne mają następujące funkcje:

Nie można utworzyć wystąpienia klasy abstrakcyjnej.
Klasa abstrakcyjna może zawierać metody abstrakcyjne i metody dostępu.
Nie można zmodyfikować klasy abstrakcyjnej za pomocą modyfikatora zapieczętowanego , ponieważ oba modyfikatory mają odwrotne znaczenie. sealed Modyfikator uniemożliwia dziedziczenie klasy, a abstract modyfikator wymaga dziedziczenia klasy.
Klasa nie abstrakcyjna pochodząca z klasy abstrakcyjnej musi zawierać rzeczywiste implementacje wszystkich odziedziczonych metod abstrakcyjnych i metod dostępu.

abstract Użyj modyfikatora w metodzie lub deklaracji właściwości, aby wskazać, że metoda lub właściwość nie zawiera implementacji.

Metody abstrakcyjne mają następujące funkcje:

Metoda abstrakcyjna jest niejawnie metodą wirtualną.
Deklaracje metod abstrakcyjnych są dozwolone tylko w klasach abstrakcyjnych.
Ponieważ deklaracja metody abstrakcyjnej nie zapewnia rzeczywistej implementacji, nie ma treści metody; deklaracja metody kończy się średnikiem i nie ma nawiasów klamrowych ({ }) po podpisie. Na przykład:

C#
```
public abstract void MyMethod();  
```
Implementacja jest dostarczana przez zastąpienie metody, która jest elementem członkowskim klasy nie abstrakcyjnej.
Jest to błąd podczas używania modyfikatorów statycznych lub wirtualnych w abstrakcyjnej deklaracji metody.

Właściwości abstrakcyjne zachowują się jak metody abstrakcyjne, z wyjątkiem różnic w składni deklaracji i wywołania.

Jest to błąd podczas używania abstract modyfikatora we właściwości statycznej.
Właściwość dziedziczona abstrakcyjnie może zostać zastąpiona w klasie pochodnej przez dołączenie deklaracji właściwości, która używa modyfikatora przesłonięcia .

Aby uzyskać więcej informacji na temat klas abstrakcyjnych, zobacz Klasy abstrakcyjne i zapieczętowane oraz składowe klas.

Klasa abstrakcyjna musi zapewnić implementację dla wszystkich składowych interfejsu.

Klasa abstrakcyjna, która implementuje interfejs, może mapować metody interfejsu na metody abstrakcyjne. Na przykład:

interface I
{
    void M();
}

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

Przykład 2

W tym przykładzie klasa DerivedClass pochodzi z klasy BaseClassabstrakcyjnej . Klasa abstrakcyjna zawiera metodę abstrakcyjną , AbstractMethodi dwie właściwości X abstrakcyjne i 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

W poprzednim przykładzie, jeśli spróbujesz utworzyć wystąpienie klasy abstrakcyjnej przy użyciu instrukcji podobnej do następującej:

BaseClass bc = new BaseClass();   // Error

Zostanie wyświetlony błąd informujący, że kompilator nie może utworzyć wystąpienia klasy abstrakcyjnej "BaseClass".

Niemniej jednak można użyć konstruktora klasy abstrakcyjnej, jak w poniższym przykładzie

Przykład 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()}");            
     }
}

Klasa Shape jest zadeklarowana abstract, co oznacza, że nie można jej zinstancjonować bezpośrednio. Zamiast tego służy jako strategia dla innych klas.

Mimo że nie można tworzyć obiektów klasy abstrakcyjnej, nadal może mieć konstruktor. Ten konstruktor jest zazwyczaj protected, co oznacza, że można uzyskać do niego dostęp tylko z klas pochodnych. W tym przypadku konstruktor Shape przyjmuje parametr color i inicjuje właściwość Color. Wyświetla również komunikat na konsolę. Część public Square(string color, double side) : base(color) wywołuje konstruktor klasy bazowej (Shape) i przekazuje do niego argument color.
W klasie Shape zdefiniowany konstruktor przyjmuje kolor jako parametr protected Shape(string color). Oznacza to, że nie ma już domyślnego konstruktora bez parametrów dostarczanego przez język C#, dlatego klasy pochodne muszą używać wyrażenia : base(color) do wywoływania konstruktora podstawowego. Ustawienie wartości domyślnej na kolor protected Shape(string color="green") pozwoli pominąć wyrażenie : base(color) w klasach pochodnych, mimo że taki konstruktor protected Shape(string color="green") zostanie wywołany, ustawiając kolor na zielony.

Specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Udostępnij za pośrednictwem