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é:
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) { }
}Generic makes a sound
Rex: woof
Mia makes a soundPole 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:
new Child();
class Parent
{
public Parent() => Console.WriteLine("Parent ctor");
}
class Child : Parent
{
public Child() => Console.WriteLine("Child ctor");
}Parent ctor
Child ctorRozhraní 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:
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;
}Square: 9
Rect: 10
19Kó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í:
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";
}flap paddleKontrola 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:
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);Rex is a dog
TruePř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:
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";
}Derived
Base.Hi
Derived.HiWho 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
Co vypíšou ukázky z lekce?
Program s Base a Derived
Vyber správné klíčové slovo
Spoj pojem s významem
Ke každému pojmu najdi, co znamená.
Abstraktní třída, nebo rozhraní?
Roztřiď vlastnosti podle toho, ke kterému nástroji patří.
Najdi chybu v tomto kódu:
class A { public string Hi() => "A"; }
class B : A { public override string Hi() => "B"; }Proč se kód výše nepřeloží?
Přepsat jde jen metoda označená virtual, abstract nebo override. Řešení: přidej virtual do A.
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?
U virtuálních metod se vybírá podle skutečného typu objektu. To je polymorfismus.
Co vypíše Base b = new Derived(); Console.WriteLine(b.Hi());, když Derived metodu Hi skrývá přes new?
Skrytá (ne virtuální) metoda se volá podle typu proměnné. Proměnná je Base, a tak se zavolá Base.Hi.
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.