How do inheritance and polymorphism work?

Question

Accepted Answer

**Inheritance** lets a class derive from a base class, reusing and extending its members. **Polymorphism** lets you treat derived objects through a base type, with the correct overridden method called at runtime (via `virtual`/`override`). These are core OOP mechanisms in C#.

## Inheritance

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

A derived class (`Dog : Animal`) inherits the base's members and can add its own. C# supports **single inheritance** (one base class). `base.Method()` calls the base implementation.

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

**Polymorphism**: a `virtual` method overridden in derived classes is dispatched at **runtime** based on the object's actual type — so the same call (`a.MakeSound()`) does different things per type. This enables flexible, extensible code (handle many types uniformly).

## Abstract classes and 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
```

**Abstract classes** define a partial base (with abstract methods subclasses must implement plus shared code); `sealed` prevents further inheritance.

## Why it matters

Inheritance and polymorphism are core OOP mechanisms in C#, fundamental to object-oriented design and to working with the .NET framework (which uses them extensively), so understanding them is essential. **Inheritance** provides code reuse via "is-a" relationships (a Dog is an Animal), though C# allows only single inheritance. **Polymorphism** — through `virtual`/`override` and runtime method dispatch — is particularly important: it lets you treat different derived types uniformly through a base type while the correct type-specific behavior runs automatically, enabling flexible, extensible designs (process a collection of different shapes, each computing its own area).

Understanding the `virtual`/`override` mechanism (the base marks a method overridable, derived classes override it, and the runtime dispatches to the actual type's version), **abstract classes** (partial bases with methods subclasses must implement plus shared code), and `sealed` (preventing inheritance) is necessary for designing class hierarchies and for understanding how the .NET framework and libraries are structured.

Since inheritance and polymorphism underpin object-oriented C# and the framework itself, and since runtime polymorphism is a key enabler of extensible, maintainable code, mastering these — especially the virtual/override dispatch that makes polymorphism work — is important, frequently-applied knowledge for object-oriented design in C#, and a common interview topic that reveals understanding of OOP fundamentals.