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

absztrakt (C# referencia)

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 XY .

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

Mindazonáltal egy absztrakt osztálykonstruktort is használhatunk, ahogyan az alábbi példában is látható

3. példa

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

A Shape osztály abstractdeklarálva van, ami azt jelenti, hogy nem hozható létre közvetlenül. Ehelyett más osztályok tervrajzaként szolgál.

  • Annak ellenére, hogy nem hozhat létre absztrakt osztály objektumait, még mindig rendelkezhet konstruktorsal. Ez a konstruktor általában protected, ami azt jelenti, hogy csak származtatott osztályokból érhető el. Ebben az esetben a Shape konstruktor egy color paramétert vesz fel, és inicializálja a Color tulajdonságot. Emellett egy üzenetet is kinyomtat a konzolra. A public Square(string color, double side) : base(color) rész meghívja az alaposztály konstruktorát (Shape), és átadja neki a color argumentumot.
  • Az Alakzat osztályban a definiált konstruktor egy színt vesz fel paraméterként protected Shape(string color). Ez azt jelenti, hogy a C# már nem biztosít automatikusan paraméter nélküli alapértelmezett konstruktort, így a származtatott osztályoknak a : base(color) kifejezést kell használniuk az alapkonstruktor meghívásához. Az alapértelmezett érték színértékre állítása protected Shape(string color="green") lehetővé teszi, hogy a : base(color) kifejezést kihagyják a leszármaztatott osztályokban; azonban ilyen esetben a rendszer protected Shape(string color="green") konstruktort fog meghívni, amely zöldre állítja a színt.

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