Jak działają dziedziczenie i polimorfizm?

Question

Accepted Answer

**Dziedziczenie** pozwala klasie dziedziczyć z klasy bazowej, ponownie wykorzystując i rozszerzając jej elementy. **Polimorfizm** pozwala traktować obiekty pochodne przez typ bazowy, z prawidłową nadpisaną metodą wywoływaną w czasie wykonania (poprzez `virtual`/`override`). Są to mechanizmy OOP w języku C#.

## Dziedziczenie

```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"
```

Klasa pochodna (`Dog : Animal`) dziedziczy elementy bazy i może dodać własne. C# obsługuje **dziedziczenie pojedyncze** (jedna klasa bazowa). `base.Method()` wywołuje implementację bazową.

## Polimorfizm — 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
```

**Polimorfizm**: metoda `virtual` nadpisana w klasach pochodnych jest wysyłana w **czasie wykonania** na podstawie rzeczywistego typu obiektu — więc to samo wywołanie (`a.MakeSound()`) robi różne rzeczy w zależności od typu. Umożliwia to elastyczne, rozszerzalne kody (obsługiwanie wielu typów jednolicie).

## Klasy abstrakcyjne i 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
```

**Klasy abstrakcyjne** definiują częściową bazę (z metodami abstrakcyjnymi, które podklasy muszą implementować, plus kod wspólny); `sealed` uniemożliwia dalsze dziedziczenie.

## Dlaczego to ważne

Dziedziczenie i polimorfizm są mechanizmami OOP w języku C#, fundamentalnymi dla projektowania zorientowanego obiektowo i pracy z framework'iem .NET (który je intensywnie wykorzystuje), dlatego zrozumienie ich jest niezbędne. **Dziedziczenie** zapewnia ponowne wykorzystanie kodu poprzez relacje "jest-a" (Dog jest Animal), choć C# pozwala tylko na pojedyncze dziedziczenie. **Polimorfizm** — poprzez `virtual`/`override` i wysyłkę metod w czasie wykonania — jest szczególnie ważny: pozwala traktować różne typy pochodne jednolicie przez typ bazowy, podczas gdy prawidłowe zachowanie specyficzne dla typu działa automatycznie, umożliwiając elastyczne, rozszerzalne projekty (przetwarzanie kolekcji różnych kształtów, każdy obliczający własne pole).

Zrozumienie mechanizmu `virtual`/`override` (baza oznacza metodę możliwą do nadpisania, klasy pochodne ją nadpisują, a runtime wysyła do wersji rzeczywistego typu), **klasy abstrakcyjne** (częściowe bazy z metodami, które podklasy muszą implementować, plus kod wspólny) i `sealed` (uniemożliwiający dziedziczenie) jest niezbędne do projektowania hierarchii klas i zrozumienia struktury framework'u .NET i bibliotek.

Ponieważ dziedziczenie i polimorfizm stanowią fundament zorientowanego obiektowo C# i samego framework'u, a polimorfizm w czasie wykonania jest kluczowym czynnikiem umożliwiającym elastyczne, łatwe w utrzymaniu kody, opanowanie tych mechanizmów — szczególnie wysyłki virtual/override, która sprawia, że polimorfizm działa — jest ważną, często stosowaną wiedzą do projektowania obiektowego w C# i powszechnym tematem rozmów o pracę, który ujawnia zrozumienie fundamentów OOP.