0 bodů

C# · 45 min

Dědičnost a rozhraní

Dědičnost tříd, virtual a override, abstraktní třídy, rozhraní a polymorfismus: jak jeden kód pracuje s různými objekty a kde číhá skrývání členů přes new.

Lidsky řečeno

Dědičnost je jako rodinná firma: syn dostane po otci dílnu a nářadí a jen si k tomu přidá vlastní řemeslo. Rozhraní je naopak pracovní smlouva: nezajímá tě, kdo to je, jen že umí to, co smlouva říká (třeba „umí zazvonit“). Polymorfismus je, že zavoláš „zazvoň!“ a zvonek, budík i telefon zazvoní každý po svém.

Obtížnost: 4 z 5. Předpoklad: .NET 10 (LTS) a C# 14, kód funguje od .NET 8 / C# 12.

Dědičnost a virtual, override

Potomek (: Animal) zdědí členy předka. Metoda, kterou smí potomek přepsat, se v předkovi označí virtual, v potomkovi override. Při volání rozhoduje skutečný typ objektu, ne typ proměnné:

csharp
Animal[] zoo = { new Animal("Generic"), new Dog("Rex"), new Cat("Mia") };
foreach (Animal a in zoo)
    Console.WriteLine(a.Speak());

class Animal
{
    public string Name { get; }
    public Animal(string name) => Name = name;
    public virtual string Speak() => $"{Name} makes a sound";
}

class Dog : Animal
{
    public Dog(string name) : base(name) { }
    public override string Speak() => $"{Name}: woof";
}

class Cat : Animal
{
    public Cat(string name) : base(name) { }
}
text
Generic makes a sound
Rex: woof
Mia makes a sound

Pole drží typ Animal, ale pes odpoví po svém. Tomu se říká polymorfismus (mnohotvarost). Kočka Speak nepřepsala, a proto použije verzi předka. Zápis : base(name) předá jméno konstruktoru předka. Uvnitř potomka zavoláš původní verzi metody přes base.Speak().

Pořadí konstruktorů

Nejdřív se vždy provede konstruktor předka, potom potomka:

csharp
new Child();

class Parent
{
    public Parent() => Console.WriteLine("Parent ctor");
}

class Child : Parent
{
    public Child() => Console.WriteLine("Child ctor");
}
text
Parent ctor
Child ctor

Rozhraní a abstraktní třída

Rozhraní (interface) popisuje, co objekt umí, bez implementace. Třída jich může implementovat víc. Abstraktní třída je nedokončený předek: může obsahovat sdílený kód a abstract členy, které musí potomek dodat. Její instanci vytvořit nejde:

csharp
IShape[] shapes = { new Square(3), new Rect(2, 5) };
int total = 0;
foreach (IShape s in shapes)
{
    Console.WriteLine($"{s.Name}: {s.Area()}");
    total += s.Area();
}
Console.WriteLine(total);

interface IShape
{
    string Name { get; }
    int Area();
}

abstract class ShapeBase : IShape
{
    public abstract string Name { get; }
    public abstract int Area();
}

class Square(int side) : ShapeBase
{
    public override string Name => "Square";
    public override int Area() => side * side;
}

class Rect(int w, int h) : ShapeBase
{
    public override string Name => "Rect";
    public override int Area() => w * h;
}
text
Square: 9
Rect: 10
19

Kód ve smyčce zná jen IShape, a tak ho nezajímá, kolik různých tvarů přibude. Rozhraní se tradičně pojmenovávají s písmenem I na začátku. Třída smí dědit jen z jedné třídy, ale implementovat libovolně mnoho rozhraní:

csharp
var duck = new Duck();
Console.WriteLine(duck.Fly() + " " + duck.Swim());

interface IFlyer { string Fly(); }
interface ISwimmer { string Swim(); }

class Duck : IFlyer, ISwimmer
{
    public string Fly() => "flap";
    public string Swim() => "paddle";
}
text
flap paddle

Kontrola typu: is a as

Přes proměnnou předka vidíš jen členy předka. Zjistit konkrétní typ pomůže is (s deklarací proměnné) nebo as (vrátí null, když typ nesedí). Třídy Animal, Dog a Cat jsou stejné jako v první ukázce, změní se jen příkazy nahoře:

csharp
Animal a = new Dog("Rex");
if (a is Dog d)
    Console.WriteLine($"{d.Name} is a dog");
Animal c = new Cat("Mia");
Dog? x = c as Dog;
Console.WriteLine(x == null);
text
Rex is a dog
True

Přetypování (Dog)c by na kočce vyhodilo InvalidCastException. Proto je as nebo is bezpečnější.

Úskalí: new skrývá, override přepisuje

Metoda bez virtual se nepřepisuje, jen skrývá (new). A skrytá metoda se volá podle typu proměnné, ne objektu:

csharp
Base b = new Derived();
Console.WriteLine(b.Who());
Console.WriteLine(b.Hi());
Derived d = new Derived();
Console.WriteLine(d.Hi());

class Base
{
    public virtual string Who() => "Base";
    public string Hi() => "Base.Hi";
}

class Derived : Base
{
    public override string Who() => "Derived";
    public new string Hi() => "Derived.Hi";
}
text
Derived
Base.Hi
Derived.Hi

Who je virtuální, takže vyhraje potomek. Hi jen zakrývá, takže přes proměnnou typu Base se volá verze Base.Hi. Bez slova new překladač varuje (CS0108).

Procvič si to

Doplň

Co vypíšou ukázky z lekce?

Doplň

Program s Base a Derived

Vyber

Vyber správné klíčové slovo

Spoj dvojice

Spoj pojem s významem

Ke každému pojmu najdi, co znamená.

Roztřiď

Abstraktní třída, nebo rozhraní?

Roztřiď vlastnosti podle toho, ke kterému nástroji patří.

Najdi chybu v tomto kódu:

csharp
class A { public string Hi() => "A"; }
class B : A { public override string Hi() => "B"; }
Kvíz

Proč se kód výše nepřeloží?

Kvíz

Animal a = new Dog("Rex"); Console.WriteLine(a.Speak()); Která verze Speak se zavolá, když je v Animal virtuální a Dog ji přepisuje?

Kvíz

Co vypíše Base b = new Derived(); Console.WriteLine(b.Hi());, když Derived metodu Hi skrývá přes new?

Pod kapotou · Default metody rozhraní, sealed a Liskovové

Od C# 8 smí mít rozhraní i výchozí implementaci metody. Volá se přes proměnnou typu rozhraní. Třída s sealed už nejde zdědit (rychlejší volání a jasnější návrh), sealed override zastaví přepisování dál. Návrhové pravidlo Liskovové říká, že potomek musí jít použít všude, kde se čeká předek, bez překvapení. Častá rada zní kompozice před dědičností: místo „je to“ (dědění) raději „má to“ (objekt uvnitř jiného), protože hluboké stromy dědičnosti se špatně mění. Rozhraní se hodí u injektování závislostí a při psaní testů, kde objekt nahradíš náhradou.

Kartičky

Opakování: dědičnost a rozhraní