Cum funcționează moștenirea și polimorfismul?

Question

Accepted Answer

**Moștenirea** permite unei clase să deriveze dintr-o clasă de bază, reutilizând și extinzând membrii acesteia. **Polimorfismul** vă permite să tratați obiecte derivate printr-un tip de bază, cu metoda corectă suprascrisă apelată în timpul execuției (prin `virtual`/`override`). Acestea sunt mecanisme fundamentale ale OOP în C#.

## Moștenirea

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

O clasă derivată (`Dog : Animal`) moștenește membrii bazei și poate adăuga ai săi. C# suportă **moștenire simplă** (o singură clasă de bază). `base.Method()` apelează implementarea din bază.

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

**Polimorfismul**: o metodă `virtual` suprascrisă în clase derivate este expedită la **runtime** pe baza tipului actual al obiectului — deci același apel (`a.MakeSound()`) face lucruri diferite per tip. Aceasta permite cod flexibil, extensibil (tratarea multor tipuri uniform).

## Clase abstracte ș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
```

**Clasele abstracte** definesc o bază parțială (cu metode abstracte pe care subclasele trebuie să le implementeze, plus cod partajat); `sealed` previne moștenirea ulterioară.

## De ce este important

Moștenirea și polimorfismul sunt mecanisme fundamentale ale OOP în C#, esențiale pentru proiectarea orientată pe obiecte și pentru lucrul cu framework-ul .NET (care le utilizează extensiv), deci înțelegerea lor este obligatorie. **Moștenirea** oferă reutilizare de cod prin relații "is-a" (un Dog este un Animal), deși C# permite doar moștenire simplă. **Polimorfismul** — prin `virtual`/`override` și expediția metodelor la runtime — este deosebit de important: vă permite să tratați tipuri derivate diferite uniform printr-un tip de bază, în timp ce comportamentul specific al tipului se execută automat, permițând proiecte flexibile și extensibile (procesarea unei colecții de forme diferite, fiecare calculând propria sa arie).

Înțelegerea mecanismului `virtual`/`override` (baza marchează o metodă ca suprascrisă, clasele derivate o suprascriu, iar runtime-ul expedază către versiunea tipului actual), **clasele abstracte** (baze parțiale cu metode pe care subclasele trebuie să le implementeze, plus cod partajat), și `sealed` (prevenirea moștenirii) este necesară pentru proiectarea ierarhiilor de clase și pentru înțelegerea modului în care framework-ul .NET și bibliotecile sunt structurate.

Dintru că moștenirea și polimorfismul sunt fundamentul C# orientat pe obiecte și al framework-ului însuși, și deoarece polimorfismul la runtime este un factor cheie în enablement-ul codului extensibil și ușor de întreținut, stăpânirea acestora — în special expediția virtual/override care face polimorfismul să funcționeze — este cunoștință importantă, frecvent aplicată pentru proiectarea orientată pe obiecte în C#, și un subiect frecvent al interviurilor care relevă înțelegerea fundamentelor OOP.