Megosztás a következőn keresztül:

absztrakt (C# referencia)

  • Cikk

A abstract módosító azt jelzi, hogy a módosítandó dolog végrehajtása hiányzik vagy hiányos. Az absztrakt módosító osztályokkal, metódusokkal, tulajdonságokkal, indexelőkkel és eseményekkel használható. abstract Az osztálydeklaráció módosítójával jelezheti, hogy egy osztály csak más osztályok alaposztálya, és nem példányosítva. Az absztraktként megjelölt tagokat nem absztrakt osztályoknak kell megvalósítaniuk, amelyek az absztrakt osztályból származnak.

1. példa

Ebben a példában az osztálynak Square meg kell adnia egy implementációt GetArea , mert a következőből Shapeszármazik:

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

Az absztrakt osztályok a következő funkciókkal rendelkeznek:

  • Absztrakt osztály nem hozható létre.

  • Az absztrakt osztályok absztrakt metódusokat és tartozékokat tartalmazhatnak.

  • A lezárt módosítóval nem lehet módosítani egy absztrakt osztályt, mert a két módosító ellentétes jelentéssel rendelkezik. A sealed módosító megakadályozza egy osztály öröklését, és a abstract módosító megköveteli az osztály öröklését.

  • Az absztrakt osztályból származtatott nem absztrakt osztálynak tartalmaznia kell az összes örökölt absztrakt metódus és tartozék tényleges implementációit.

abstract A módosító egy metódusban vagy tulajdonságdeklarációban azt jelzi, hogy a metódus vagy tulajdonság nem tartalmaz implementációt.

Az absztrakt metódusok a következő funkciókkal rendelkeznek:

  • Az absztrakt metódus implicit módon virtuális módszer.

  • Az absztrakt metódus deklarációi csak absztrakt osztályokban engedélyezettek.

  • Mivel az absztrakt metódus deklarációja nem biztosít tényleges megvalósítást, nincs metódustörzs; a metódusdeklaráció egyszerűen pontosvesszővel végződik, és az aláírás után nincs kapcsos zárójel ({ }). Példa:

    public abstract void MyMethod();

    A megvalósítást egy metódus felülbírálása biztosítja, amely egy nem absztrakt osztály tagja.

  • Hiba a statikus vagy virtuális módosítók használata absztrakt metódus deklarációjában.

Az absztrakt tulajdonságok absztrakt metódusokhoz hasonlóan viselkednek, kivéve a deklaráció és a meghívás szintaxisának különbségeit.

  • Hiba a módosító statikus tulajdonságon való használata abstract .

  • Az absztrakt öröklődő tulajdonság felülbírálható egy származtatott osztályban a felülbírálási módosítót használó tulajdonságdeklarációval.

Az absztrakt osztályokról további információt az Absztrakt és a Lezárt osztályok és osztálytagok című témakörben talál.

Az absztrakciós osztálynak minden felülettag számára implementációt kell biztosítania.

Az interfészt megvalósító absztrakt osztály absztrakciós módszerekre képezheti le a felületi metódusokat. Példa:

interface I
{
    void M();
}

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

2. példa

Ebben a példában az osztály DerivedClass egy absztrakt osztályból BaseClassszármazik. Az absztrakt osztály tartalmaz egy absztrakt metódust, AbstractMethodvalamint két absztrakt tulajdonságot és YX .

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

Az előző példában, ha az absztrakt osztályt az alábbihoz hasonló utasítással próbálja példányosítani:

BaseClass bc = new BaseClass();   // Error

Hibaüzenet jelenik meg, amely szerint a fordító nem tudja létrehozni a "BaseClass" absztrakt osztály egy példányát.

C# nyelvi specifikáció

További információkért lásd a C# nyelvi specifikációját. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

Lásd még