# Inheritance Review

A quick look back at inheritance in C#. A derived class names its base class after a colon, inherits its members, adds its own, and overrides the base class's virtual methods.

Apprentice · C# · OOP · Updated November 3, 2026

## After this lesson you can

- Read a base class and a derived class, and say what the derived class inherits, adds and overrides

## Key takeaways

- In `class Archer : Character`, `Archer` is the derived class and inherits `Character`'s `Name`, `Health` and `Level` without writing them.
- A derived class can add members of its own, such as `Arrows`, which only archers have.
- In the archer's constructor, `: base(name)` passes the name on to `Character`'s constructor.
- A derived class may `override` a `virtual` method, and `base.LevelUp()` runs the base class's version inside the override.

Abstract classes are built on inheritance, so here's a quick reminder of how it works in C#. Inheritance is an **is-a** relationship: an archer **is a** character, so `Archer` inherits everything `Character` has.

## The base class and a derived class

```csharp
Archer robin = new Archer("Robin");
robin.LevelUp();

Console.WriteLine($"{robin.Name}: level {robin.Level}, arrows {robin.Arrows}, {robin.SpecialAbility()}");

public class Character
{
    public string Name { get; }
    public int Health { get; protected set; } = 100;
    public int Level { get; protected set; } = 1;

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

    public virtual void LevelUp()
    {
        Level++;
        Health += 10;
    }

    public virtual string SpecialAbility()
    {
        return "None";
    }
}

public class Archer : Character
{
    public int Arrows { get; private set; }

    public Archer(string name) : base(name)
    {
    }

    public override void LevelUp()
    {
        base.LevelUp();
        Arrows++;
    }

    public override string SpecialAbility()
    {
        return "Rain of arrows";
    }
}
```

```text
Robin: level 2, arrows 1, Rain of arrows
```

## What each part does

| In the code | What it means |
|---|---|
| `class Archer : Character` | `Archer` is the **derived class**, `Character` its **base class**. |
| `Name`, `Health`, `Level` | **Inherited**: `Archer` never wrote them, but every archer has them. |
| `Arrows` | **Added**: only archers have it. |
| `: base(name)` | The archer's constructor passes the name on to `Character`'s constructor. |
| `virtual` in `Character` | Derived classes **may** change this method. |
| `override` in `Archer` | `Archer` **replaces** the method with its own version. |
| `base.LevelUp()` | The override runs `Character`'s version first, then adds the arrow. |

## Notice what Character can do

`Character` is a complete class. `new Character("Villager")` makes a perfectly good villager, whose special ability is *None*.

That works for characters. But some base classes describe an idea so general that an object of just that class makes no sense. You can open a checking account or a savings account, but not an account of no kind at all. The next lesson shows how C# handles those.

## Check yourself

1 question to try on the lesson page.

## So what

Inherit what's shared, add what's new, override what's different. Keep that picture in mind: an abstract class is the same picture with one rule added.

## Key terms

- [Inheritance](https://www.ask-codey.com/glossary/inheritance-c-sharp)
- [Derived Class](https://www.ask-codey.com/glossary/derived-class)
- [Method Overriding](https://www.ask-codey.com/glossary/method-overriding-c-sharp)

## Cheat sheets

- [Inheritance Review](https://www.ask-codey.com/cheat-sheets/abstraction-in-csharp-inheritance-review-cheat-sheet)

Source: https://www.ask-codey.com/lessons/abstraction-in-csharp-inheritance-review