Jak fungují dědičnost a polymorfismus?

Question

Accepted Answer

**Dědičnost** umožňuje třídě vycházet ze základní třídy, opakovaně používat a rozšiřovat její členy. **Polymorfismus** vám umožňuje zacházet s odvozenými objekty prostřednictvím základního typu, přičemž správná přepsaná metoda se volá za běhu (prostřednictvím `virtual`/`override`). Jedná se o základní mechanismy OOP v C#.

## Dědičnost

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

Odvozená třída (`Dog : Animal`) dědí členy základní třídy a může přidat své vlastní. C# podporuje **jedinou dědičnost** (jedna základní třída). `base.Method()` volá implementaci základní třídy.

## Polymorfismus — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**Polymorfismus**: metoda `virtual` přepsaná v odvozených třídách se **za běhu** odesílá na základě skutečného typu objektu — takže stejné volání (`a.MakeSound()`) dělá různé věci pro různé typy. To umožňuje flexibilní, rozšiřitelný kód (jednotné zpracování mnoha typů).

## Abstraktní třídy a sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**Abstraktní třídy** definují částečný základ (s abstraktními metodami, které musí podtřídy implementovat, plus sdílený kód); `sealed` zabraňuje další dědičnosti.

## Proč je to důležité

Dědičnost a polymorfismus jsou základní mechanismy OOP v C#, základem objektově orientovaného návrhu a práce s frameworkem .NET (který je hojně využívá), takže jejich pochopení je nezbytné. **Dědičnost** poskytuje opakované použití kódu prostřednictvím vztahů "je-a" (Dog je Animal), ačkoli C# umožňuje pouze jedinou dědičnost. **Polymorfismus** — prostřednictvím `virtual`/`override` a odesílání metod za běhu — je obzvláště důležitý: umožňuje vám jednotné zpracování různých odvozených typů prostřednictvím základního typu, přičemž se automaticky spustí správné chování specifické pro typ, což umožňuje flexibilní, rozšiřitelné návrhy (zpracování kolekce různých tvarů, z nichž každý počítá svou vlastní plochu).

Pochopení mechanismu `virtual`/`override` (základní třída označí metodu jako přepisovatelnou, odvozené třídy ji přepíší a runtime odesílá na verzi skutečného typu), **abstraktních tříd** (částečné báze s metodami, které musí podtřídy implementovat, plus sdílený kód) a `sealed` (prevence dědičnosti) je nezbytné pro navrhování hierarchií tříd a pro pochopení, jak je framework .NET a knihovny strukturovány.

Protože dědičnost a polymorfismus jsou základem objektově orientovaného C# a samotného frameworku, a protože runtime polymorfismus je klíčovým faktorem rozšiřitelného a udržovatelného kódu, zvládnutí těchto mechanismů — zejména virtual/override odesílání, které polymorfismus umožňuje — je důležitým a často aplikovaným vědomím pro objektově orientovaný návrh v C# a běžným tématem na pohovorech, které odhaluje pochopení základů OOP.