Inheritance: base and derived classes

Why inheritance?

A bank has savings accounts and current accounts. Both have an account number, an owner and a balance, and both accept deposits. Copying that code into two classes means fixing every bug twice. Inheritance lets both classes share one base class, Account, and add only what is different.

The "is-a" test

Use inheritance only when the derived class truly IS a kind of the base class. A SavingsAccount is an Account: good. A Car is not an Engine, it HAS an engine, so give Car an Engine property instead. That second style is called composition, and it is often the better choice.

Writing a base and a derived class

public class Account
{
    public string Owner { get; }
    public decimal Balance { get; protected set; }   // derived classes may set it

    public Account(string owner, decimal opening)
    {
        Owner = owner;
        Balance = opening;
    }

    public void Deposit(decimal amount) => Balance += amount;

    public virtual string Describe() => $"{Owner}: {Balance:F2}";
}

public class SavingsAccount : Account
{
    public decimal InterestRate { get; }

    public SavingsAccount(string owner, decimal opening, decimal rate)
        : base(owner, opening)          // run the base constructor first
    {
        InterestRate = rate;
    }

    public void AddYearlyInterest() => Balance += Balance * InterestRate;

    public override string Describe() => base.Describe() + $" (savings @ {InterestRate:P0})";
}

var s = new SavingsAccount("Asha", 10000m, 0.04m);
s.Deposit(2000m);          // inherited from Account
s.AddYearlyInterest();     // only SavingsAccount has this
Console.WriteLine(s.Describe());

virtual, override and base

• virtual on a base method says "derived classes may replace this".
• override in the derived class gives the new version. The signature must match.
• base.Describe() inside the override calls the base version, so you can extend instead of rewriting.
• Methods are NOT virtual unless you say so. This is different from Java, where methods are virtual by default.

Constructors and inheritance

Constructors are not inherited. When you create a SavingsAccount, the base constructor runs first, then the derived one. If the base class has no constructor without parameters, the derived constructor must call one with : base(...), or the code does not compile.

sealed: stop here

public sealed class FixedDeposit : Account
{
    public FixedDeposit(string owner, decimal amount) : base(owner, amount) { }
}
// public class SpecialFd : FixedDeposit { }   // error: cannot derive from sealed type

Hiding with new: usually a mistake

Basic b = new Premium();
Console.WriteLine(b.Name());   // Basic!

class Basic { public string Name() => "Basic"; }
class Premium : Basic { public new string Name() => "Premium"; }

Everything inherits from object

Every C# type ultimately inherits from System.Object (object). That is why every object has ToString(), Equals() and GetHashCode(), and why you write override string ToString().

Common mistakes and fixes

• Forgetting override: the compiler warns CS0114 that the method hides the inherited one. Add override (and make sure the base method is virtual).
• Base class without a parameterless constructor and no : base(...) call: error CS7036. Call the right base constructor.
• Deep hierarchies (A : B : C : D : E): hard to understand and change. Keep it to one or two levels and prefer composition.
• Trying to inherit from two classes: C# allows one base class. Use interfaces (next topics) for extra abilities.