📝 Lesson 5.3: Polymorphism and Abstract Classes

What Is Polymorphism?

The word polymorphism means "many forms." In programming, it's the ability for a single piece of code — one method call — to behave differently depending on the actual type of the object it's working with.

You already built the machinery in Lesson 5.1 with virtual and override. Polymorphism is what that machinery enables: you call Speak() on an Animal reference, and the right version runs — Dog's bark or Cat's meow — decided automatically at runtime.

💡 The one-sentence idea: Write your code against the general type (Animal, IPlayable, Shape), and each specific object supplies its own behavior. Add new types later and the old code just works.

Polymorphism in Action

Here's the payoff. Recall the Animal family from Lesson 5.1, with a virtual Speak() that Dog and Cat override. Watch what happens when we hold them all as Animal:

class Animal
{
    public string Name { get; set; }
    public virtual void Speak() => Console.WriteLine($"{Name} makes a sound.");
}

class Dog : Animal
{
    public override void Speak() => Console.WriteLine($"{Name} says: Woof!");
}

class Cat : Animal
{
    public override void Speak() => Console.WriteLine($"{Name} says: Meow!");
}

// A list of the BASE type — holding different derived objects
List<Animal> zoo = new List<Animal>
{
    new Dog { Name = "Rex" },
    new Cat { Name = "Felix" },
    new Dog { Name = "Buddy" }
};

foreach (Animal animal in zoo)
{
    animal.Speak();     // each runs ITS OWN version — this is polymorphism
}

Rex says: Woof!
Felix says: Meow!
Buddy says: Woof!

The loop variable is an Animal, yet each call dispatches to the correct override. The loop doesn't know or care whether an item is a Dog or Cat — and that's exactly why it's powerful.

Abstract Classes

Sometimes a base class represents a concept that's too general to exist on its own. What is a plain Animal, with no species? What does a generic Shape look like? These make sense as blueprints, but you'd never create one directly.

An abstract class captures exactly that. Mark a class abstract and it cannot be instantiated — it exists only to be inherited from:

abstract class Shape
{
    public string Name { get; set; }

    // A normal (concrete) method — shared by all shapes
    public void Describe()
    {
        Console.WriteLine($"This is a {Name}.");
    }
}

// Shape circle = new Shape();   // ❌ Error — can't create an abstract class

class Circle : Shape { }          // ✅ a concrete class can inherit it
Circle c = new Circle { Name = "circle" };
c.Describe();                     // This is a circle.

Abstract Methods

Abstract classes can go one step further. An abstract method has no body — just a signature — and it forces every derived class to provide its own implementation. It's like an interface member living inside a class:

abstract class Shape
{
    public string Name { get; set; }

    // Abstract: no body. Every concrete shape MUST implement this.
    public abstract double Area();

    // Concrete: shared logic that even uses the abstract method
    public void Report()
    {
        Console.WriteLine($"{Name} has an area of {Area():F2}");
    }
}

class Circle : Shape
{
    public double Radius { get; set; }

    public override double Area()          // required — override the abstract method
    {
        return Math.PI * Radius * Radius;
    }
}

class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double Area()
    {
        return Width * Height;
    }
}

Now polymorphism and abstraction combine beautifully:

List<Shape> shapes = new List<Shape>
{
    new Circle { Name = "Circle", Radius = 5 },
    new Rectangle { Name = "Rectangle", Width = 4, Height = 6 }
};

foreach (Shape shape in shapes)
{
    shape.Report();     // calls the shared Report(), which calls each Area()
}

Circle has an area of 78.54
Rectangle has an area of 24.00

Abstract Class vs. Interface

Both let you write polymorphic code and both can force derived types to implement members. So which do you choose?

💡 Rule of thumb: Use an abstract class when your derived types are a family that shares real code (like Shape with its Report()). Use an interface when otherwise-unrelated types just need to promise the same capability. And remember — a class can do both: inherit one abstract base and implement several interfaces.

Exercise & Quiz

List<Employee> staff = new List<Employee>
{
    new SalariedEmployee { Name = "Ada", MonthlySalary = 5000m },
    new HourlyEmployee { Name = "Grace", HourlyRate = 30m, HoursWorked = 120 }
};

foreach (Employee e in staff)
{
    e.PrintPay();
}

abstract class Employee
{
    public string Name { get; set; }
    public abstract decimal CalculatePay();

    public void PrintPay()
    {
        Console.WriteLine($"{Name}: {CalculatePay():C}");
    }
}

// TODO: SalariedEmployee : Employee  (MonthlySalary)
// TODO: HourlyEmployee : Employee    (HourlyRate, HoursWorked)

List<Employee> staff = new List<Employee>
{
    new SalariedEmployee { Name = "Ada", MonthlySalary = 5000m },
    new HourlyEmployee { Name = "Grace", HourlyRate = 30m, HoursWorked = 120 }
};

foreach (Employee e in staff)
{
    e.PrintPay();
}

abstract class Employee
{
    public string Name { get; set; }
    public abstract decimal CalculatePay();

    public void PrintPay()
    {
        Console.WriteLine($"{Name}: {CalculatePay():C}");
    }
}

class SalariedEmployee : Employee
{
    public decimal MonthlySalary { get; set; }

    public override decimal CalculatePay()
    {
        return MonthlySalary;
    }
}

class HourlyEmployee : Employee
{
    public decimal HourlyRate { get; set; }
    public int HoursWorked { get; set; }

    public override decimal CalculatePay()
    {
        return HourlyRate * HoursWorked;
    }
}

Ada: $5,000.00
Grace: $3,600.00

Summary & Course Wrap-Up

🚀 Where to Go Next

You now have a genuinely solid foundation in C# and object-oriented programming. Excellent next steps include:

• Exception handling: try/catch/finally for handling problems gracefully
• Generics: writing reusable, type-safe code with <T>
• LINQ: an elegant way to query and transform collections
• Files & JSON: reading and writing data that outlives your program
• Async programming: async/await for responsive apps
• Build something bigger: a web API with ASP.NET Core, a game with Unity, or a desktop app with .NET MAUI

Many of these are covered in the follow-up Intermediate C# course.

📚 Recommended Resources

• Polymorphism — Microsoft Docs
• The abstract keyword — reference
• Microsoft C# Documentation & tutorials