absztrakt (C# referencia)

A abstract módosító azt jelzi, hogy a cél egy hiányzó vagy hiányos implementációval rendelkezik. Használja az absztrakt módosító osztályokat, metódusokat, tulajdonságokat, indexelőket és eseményeket. 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 absztrakt osztályból származó nem absztrakt osztályoknak absztraktként megjelölt tagokat kell implementálniuk.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

Az absztrakt osztályok tartalmazhatnak absztrakt tagokat (amelyek nem rendelkeznek implementációval, és a származtatott osztályokban felül kell bírálni) és teljes mértékben implementált tagokat (például normál metódusokat, tulajdonságokat és konstruktorokat). Ez a funkció lehetővé teszi az absztrakt osztályok számára, hogy általános funkciókat nyújtsanak, miközben a származtatott osztályokra is szükség van bizonyos absztrakt tagok implementálásához.

Megjegyzés:

Alapértelmezés szerint a felület tagjai.abstract

Absztrakt osztály vegyes tagokkal

Az alábbi példa egy absztrakt osztályt mutat be, amely a implementált metódusokat és az absztrakt tagokat is tartalmazza:

namespace LanguageKeywords;

public abstract class Vehicle
{
    protected string _brand;
    
    // Constructor - implemented method in abstract class
    public Vehicle(string brand) => _brand = brand;
    
    // Implemented method - provides functionality that all vehicles share
    public string GetInfo() => $"This is a {_brand} vehicle.";
    
    // Another implemented method
    public virtual void StartEngine() => Console.WriteLine($"{_brand} engine is starting...");
    
    // Abstract method - must be implemented by derived classes
    public abstract void Move();
    
    // Abstract property - must be implemented by derived classes  
    public abstract int MaxSpeed { get; }
}

public class Car : Vehicle
{
    public Car(string brand) : base(brand) { }
    
    // Implementation of abstract method
    public override void Move() => Console.WriteLine($"{_brand} car is driving on the road.");
    
    // Implementation of abstract property
    public override int MaxSpeed => 200;
}

public class Boat : Vehicle
{
    public Boat(string brand) : base(brand) { }
    
    // Implementation of abstract method
    public override void Move() => Console.WriteLine($"{_brand} boat is sailing on the water.");
    
    // Implementation of abstract property
    public override int MaxSpeed => 50;
}

public class AbstractExample
{
    public static void Examples()
    {
        // Cannot instantiate abstract class: Vehicle v = new Vehicle("Generic"); // Error!
        
        Car car = new Car("Toyota");
        Boat boat = new Boat("Yamaha");
        
        // Using implemented methods from abstract class
        Console.WriteLine(car.GetInfo());
        car.StartEngine();
        
        // Using abstract methods implemented in derived class
        car.Move();
        Console.WriteLine($"Max speed: {car.MaxSpeed} km/h");
        
        Console.WriteLine();
        
        Console.WriteLine(boat.GetInfo());
        boat.StartEngine();
        boat.Move();
        Console.WriteLine($"Max speed: {boat.MaxSpeed} km/h");
    }
}

class Program
{
    static void Main()
    {
        AbstractExample.Examples();
    }
}
/* Output:
This is a Toyota vehicle.
Toyota engine is starting...
Toyota car is driving on the road.
Max speed: 200 km/h

This is a Yamaha vehicle.
Yamaha engine is starting...
Yamaha boat is sailing on the water.
Max speed: 50 km/h
*/

Ebben a példában az absztrakt osztály a Vehicle következőt nyújtja:

  • Implementált tagok: GetInfo() metódus, StartEngine() módszer és konstruktor – ezek a tagok minden jármű számára közös funkciókat biztosítanak.
  • Absztrakt tagok: Move() metódus és MaxSpeed tulajdonság – ezeket a tagokat minden egyes járműtípusnak végre kell hajtania.

Ez a kialakítás lehetővé teszi, hogy az absztrakt osztály megosztott funkciókat biztosítson, miközben biztosítja, hogy a származtatott osztályok járműspecifikus viselkedést valósítsanak meg.

Absztrakt osztályból származtatott betonosztály

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álypéldány nem hozható létre.
  • Az absztrakt osztályok absztrakt metódusokat és tartozékokat tartalmazhatnak.
  • Az absztrakt osztályok implementált metódusokat, tulajdonságokat, mezőket és más tagokat is tartalmazhatnak, amelyek a származtatott osztályok funkcióit biztosítják.
  • A módosító nem használható sealed absztrakt osztályban, mert a két módosító eltérő 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 implementációt, nincs metódus törzse. A metódus deklarációja egyszerűen pontosvesszővel végződik. Példa:

    public abstract void MyMethod();

    A megvalósítást egy metódus overridebiztosítja, amely egy nem absztrakt osztály tagja.

  • Hiba az absztrakt metódus deklarációjában szereplő módosítók vagy virtual módosítók használata static egy class típusban. A felületeken deklarálhatja a metódusokat és static virtual deklarálhatja static abstract a metódusokat.

    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ó használata abstract egy statikus tulajdonságon egy class típusban. A felületi deklarációkban deklarálhat static abstract vagy static virtual tulajdonságokat is megadhat.

  • Az absztrakt öröklődő tulajdonságot felül lehet bírálni egy származtatott osztályban egy módosítót használó override 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();
}

Az alábbi 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. Ennek ellenére használhat absztrakt osztálykonstruktort, ahogyan az az alábbi példában is látható.

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

Az Shape osztály deklarálva abstractvan, ami azt jelenti, hogy nem lehet közvetlenül példányosítani. 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, vagyis csak származtatott osztályok férhetnek hozzá. 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 osztályban a Shape 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 alapértelmezett paraméter nélküli konstruktort. 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ínre protected Shape(string color="green") állításával elhagyhatja a kifejezést származtatott : base(color) osztályokban. A konstruktor protected Shape(string color="green") 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

  • Last updated on