Hur fungerar arv och polymorfism?

Question

Accepted Answer

**Arv** låter en klass ärva från en basklass, återanvända och utöka dess medlemmar. **Polymorfism** låter dig behandla härledda objekt genom en bastyp, där rätt överskriven metod anropas vid körning (via `virtual`/`override`). Dessa är kärnmekanismer i OOP 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 härledd klass (`Dog : Animal`) ärver basens medlemmar och kan lägga till sina egna. C# stöder **enkel arv** (en basklass). `base.Method()` anropar basimplementeringen.

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

**Polymorfism**: en `virtual`-metod som överskrives i härledda klasser skickas **vid körning** baserat på objektets verkliga typ — så samma anrop (`a.MakeSound()`) gör olika saker per typ. Detta möjliggör flexibel, utökningsbar kod (hantera många typer enhetligt).

## Abstrakta klasser och 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
```

**Abstrakta klasser** definierar en partiell bas (med abstrakta metoder som subklasser måste implementera plus delad kod); `sealed` förhindrar vidare arv.

## Varför det är viktigt

Arv och polymorfism är kärnmekanismer i OOP i C#, grundläggande för objektorienterad design och för arbete med .NET-ramverket (som använder dem omfattande), så förståelse för dem är väsentlig. **Arv** ger kodåteranvändning via "är-en"-relationer (en Dog är en Animal), även om C# endast tillåter enkel arv. **Polymorfism** — genom `virtual`/`override` och metodskickning vid körning — är särskilt viktig: den låter dig behandla olika härledda typer enhetligt genom en bastyp medan rätt typspecifik beteende körs automatiskt, vilket möjliggör flexibla, utökningsbara designs (bearbeta en samling av olika former, var och en beräknar sitt eget område).

Det är nödvändigt att förstå mekanismen `virtual`/`override` (basen markerar en överskriv bar metod, härledda klasser överskrider den, och körningen skickar till den faktiska typens version), **abstrakta klasser** (partiella baser med metoder som subklasser måste implementera plus delad kod) och `sealed` (som förhindrar arv) för att utforma klasshierarkier och för att förstå hur .NET-ramverket och biblioteken är strukturerade.

Därför att arv och polymorfism utgör grunden för objektorienterad C# och själva ramverket, och eftersom polymorfism vid körning är en nyckelaktivering för utökningsbar, underhållbar kod, är det viktigt att bemästra dessa — särskilt den virtual/override-skickning som gör polymorfism möjlig — vilket är ofta använd kunskap för objektorienterad design i C#, och ett vanligt intervjuämne som avslöjar förståelse för OOP-grunder.