Hvordan fungerer arv og polymorfisme?

Question

Accepted Answer

**Arv** lar en klasse arve fra en baseklasse, og gjenbruke og utvide dens medlemmer. **Polymorfisme** lar deg behandle avledede objekter gjennom en basetype, med riktig overordnet metode kalt ved kjøretid (via `virtual`/`override`). Dette er kjernemekanismer i objektorientert 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 avledet klasse (`Dog : Animal`) arver baseklassens medlemmer og kan legge til sine egne. C# støtter **enkelt arv** (én baseklasse). `base.Method()` kaller baseklassens implementasjon.

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

**Polymorfisme**: en `virtual` metode som overordnes i avledede klasser blir sendt ved **kjøretid** basert på objektets faktiske type — så samme kall (`a.MakeSound()`) gjør forskjellige ting per type. Dette gjør det mulig med fleksibel, utvidbar kode (håndter mange typer enhetlig).

## 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 må implementere pluss delt kode); `sealed` forhindrer videre arv.

## Hvorfor det betyr noe

Arv og polymorfisme er kjernemekanismer i objektorientert programmering i C#, grunnleggende for objektorientert design og for arbeid med .NET-rammeverket (som bruker dem omfattende), så å forstå dem er essensielt. **Arv** gir kodegjenbruk via "er-en" forhold (en Dog er et Animal), selv om C# bare tillater enkelt arv. **Polymorfisme** — gjennom `virtual`/`override` og runtime metodeutsendesing — er særlig viktig: det lar deg behandle forskjellige avledede typer enhetlig gjennom en basetype mens riktig typesspesifikk atferd kjører automatisk, noe som muliggjør fleksible, utvidbare design (behandle en samling av forskjellige former, hver beregner sitt eget område).

Å forstå `virtual`/`override` mekanismen (basen markerer en metode som overordbar, avledede klasser overordner den, og kjøretiden sender til den faktiske typens versjon), **abstrakte klasser** (delvis baser med metoder som underklasser må implementere pluss delt kode), og `sealed` (som forhindrer arv) er nødvendig for å utforme klassehierarkier og for å forstå hvordan .NET-rammeverket og biblioteker er strukturert.

Siden arv og polymorfisme underbygger objektorientert C# og rammeverket selv, og siden runtime polymorfisme er en nøkkelfaktor for utvidbar, vedlikeholdbar kode, er det viktig å beherske disse — særlig virtual/override-utsendesingen som gjør polymorfisme mulig — som viktig, hyppig brukt kunnskap for objektorientert design i C#, og et vanlig intervjuspørsmål som avslører forståelse av objektorienterte grunnleggende prinsipper.