Hvordan fungerer arv og polymorfi?

Question

Accepted Answer

**Arv** lader en klasse udlede fra en baseklasse og genbruge og udvide dens medlemmer. **Polymorfi** lader dig behandle udledte objekter gennem en basetype, hvor den korrekte overridden metode kaldes under køretid (via `virtual`/`override`). Disse er kernemekanismer i objektorienteret programmering i C#.

## Arv

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

En udledt klasse (`Dog : Animal`) nedarver basen medlemmer og kan tilføje sine egne. C# understøtter **enkeltarv** (en baseklasse). `base.Method()` kalder basens implementering.

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

**Polymorfi**: en `virtual` metode, der overrides i udledte klasser, bliver dispatched under **køretid** baseret på objektets faktiske type — så det samme kald (`a.MakeSound()`) gør forskellige ting pr. type. Dette muliggør fleksibel, udvidelig kode (håndter mange typer ensartet).

## Abstrakte klasser og 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
```

**Abstrakte klasser** definerer en delvis base (med abstrakte metoder, som underklasser skal implementere, plus delt kode); `sealed` forhindrer yderligere arv.

## Hvorfor det betyder noget

Arv og polymorfi er kernemekanismer i objektorienteret programmering i C#, grundlæggende for objektorienteret design og arbejde med .NET-frameworket (som bruger dem omfattende), så forståelse af dem er essentiel. **Arv** giver kodegenbrug via "is-a"-relationer (en Dog er et Animal), selvom C# kun tillader enkeltarv. **Polymorfi** — gennem `virtual`/`override` og runtime-metodedispatching — er særligt vigtig: den lader dig behandle forskellige udledte typer ensartet gennem en basetype, mens den korrekte typespecifik adfærd køres automatisk, hvilket muliggør fleksible, udvidelige designs (behandl en samling af forskellige former, hver beregner sit eget område).

Forståelse af `virtual`/`override`-mekanismen (basen markerer en metode som overridable, udledte klasser overrider den, og runtime dispatcher til den faktiske types version), **abstrakte klasser** (delvis baser med metoder, som underklasser skal implementere, plus delt kode), og `sealed` (forhindrer arv) er nødvendig for at designe klassehierarkier og for at forstå, hvordan .NET-frameworket og biblioteker er struktureret.

Da arv og polymorfi ligger til grund for objektorienteret C# og frameworket selv, og da runtime-polymorfi er en vigtig aktivator for udvidelig, vedligeholdelsesvenlig kode, er det at mestre disse — især den virtual/override-dispatching, der får polymorfi til at virke — vigtig, hyppigt anvendt viden for objektorienteret design i C# og et almindeligt interviewemne, der afslører forståelse af grundlæggende OOP-principper.