📝 Lesson 5.1: Inheritance

What Is Inheritance?

Inheritance lets one class build on another. A new class can take everything an existing class has — its properties and methods — and then add or change things. This avoids duplicating code and models real-world relationships.

The test for inheritance is the "is-a" relationship. A Dog is an Animal. A SavingsAccount is a BankAccount. A Student is a Person. When one thing is a more specific kind of another, inheritance fits.

Both Dog and Cat automatically get Name and Eat() from Animal — they only add what makes them special.

Base and Derived Classes

Start with a base class — an ordinary class like the ones from Lesson 4.2:

class Animal
{
    public string Name { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

To make a class inherit from it, put a colon : and the base class name after the derived class name:

class Dog : Animal        // "Dog is an Animal"
{
    public void Bark()
    {
        Console.WriteLine($"{Name} says: Woof!");   // Name comes from Animal
    }
}

Now a Dog object has both the inherited members and its own:

Dog rex = new Dog();
rex.Name = "Rex";     // inherited property
rex.Eat();            // inherited method  → Rex is eating.
rex.Bark();           // Dog's own method  → Rex says: Woof!

Rex is eating.
Rex says: Woof!

Access: public, private, protected

Inheritance adds a third useful access level. Here's how the three you'll use compare:

Use protected when a base class has something its children need to touch, but the outside world shouldn't:

class Animal
{
    public string Name { get; set; }
    protected int energy = 100;        // children can use it; outsiders can't

    public void Eat()
    {
        energy += 10;
        Console.WriteLine($"{Name} is eating. Energy: {energy}");
    }
}

class Dog : Animal
{
    public void Run()
    {
        energy -= 20;                  // OK — 'energy' is protected
        Console.WriteLine($"{Name} runs. Energy: {energy}");
    }
}

Constructors and base

When a base class has a constructor that takes arguments, the derived class must pass those along. You do this with the base(...) call after the derived constructor's parameter list:

class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }
}

class Dog : Animal
{
    public string Breed { get; set; }

    // Pass 'name' up to the Animal constructor with base(name)
    public Dog(string name, string breed) : base(name)
    {
        Breed = breed;
    }
}

Dog rex = new Dog("Rex", "Labrador");
Console.WriteLine($"{rex.Name} is a {rex.Breed}.");   // Rex is a Labrador.

Overriding Methods

Sometimes a derived class needs to change an inherited method, not just add new ones. That's overriding. It takes two keywords working together:

• Mark the base method virtual — "this method may be overridden."
• Mark the derived method override — "this replaces the base version."

class Animal
{
    public string Name { get; set; }

    public virtual void Speak()          // virtual: can be overridden
    {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

class Dog : Animal
{
    public override void Speak()         // override: replaces the base version
    {
        Console.WriteLine($"{Name} says: Woof!");
    }
}

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

Animal generic = new Animal { Name = "Thing" };
Dog rex = new Dog { Name = "Rex" };
Cat felix = new Cat { Name = "Felix" };

generic.Speak();   // Thing makes a sound.
rex.Speak();       // Rex says: Woof!
felix.Speak();     // Felix says: Meow!

Extending, not just replacing: base.Method()

An override can also reuse the base version and add to it, by calling base.MethodName():

class Puppy : Dog
{
    public override void Speak()
    {
        base.Speak();                    // run Dog's version first...
        Console.WriteLine("(then wags tail)");   // ...then add to it
    }
}

When to Use Inheritance

Inheritance is powerful, but it's easy to overuse. A quick guide:

💡 Rule of thumb: Say the relationship out loud. "A Dog is an Animal" ✅ points to inheritance. "A Car has an Engine" ✅ points to composition (a property). If "is-a" sounds wrong, don't inherit.

Exercise & Quiz

Car car = new Car("Toyota");
Motorcycle bike = new Motorcycle("Harley");
car.Describe();
bike.Describe();

class Vehicle
{
    public string Brand { get; set; }
    public Vehicle(string brand) { Brand = brand; }

    public virtual void Describe()
    {
        Console.WriteLine($"This is a {Brand} vehicle.");
    }
}

// TODO: Car : Vehicle  (override Describe, mention 4 wheels)
// TODO: Motorcycle : Vehicle  (override Describe, mention 2 wheels)

Car car = new Car("Toyota");
Motorcycle bike = new Motorcycle("Harley");
car.Describe();
bike.Describe();

class Vehicle
{
    public string Brand { get; set; }
    public Vehicle(string brand) { Brand = brand; }

    public virtual void Describe()
    {
        Console.WriteLine($"This is a {Brand} vehicle.");
    }
}

class Car : Vehicle
{
    public Car(string brand) : base(brand) { }

    public override void Describe()
    {
        Console.WriteLine($"{Brand} car — 4 wheels, doors, and a trunk.");
    }
}

class Motorcycle : Vehicle
{
    public Motorcycle(string brand) : base(brand) { }

    public override void Describe()
    {
        Console.WriteLine($"{Brand} motorcycle — 2 wheels and no roof!");
    }
}

Toyota car — 4 wheels, doors, and a trunk.
Harley motorcycle — 2 wheels and no roof!

Summary

📚 Additional Resources

• Inheritance — Microsoft Docs
• The base keyword — reference
• Inheritance in C# — Programming Guide

🚀 What's Next?

Inheritance links classes by "is-a." But there's another way to share capabilities across unrelated classes: interfaces. In Lesson 5.2: Interfaces, you'll define contracts that any class can promise to fulfill.