Abstract classes and polymorphism

The idea of polymorphism

Polymorphism (Greek for "many forms") means you can write code against a general type and let each specific object do its own thing. A checkout page should not need a separate branch for UPI, cards and net banking. It should say "payment, process yourself", and each payment type knows how.

abstract classes

Sometimes the base class is only an idea. There is no such thing as a plain "Payment"; there is always a UPI payment or a card payment. Mark such a class abstract. You cannot create it with new, but you can use it as a variable type. An abstract method has no body; every non-abstract derived class must override it.

public abstract class Payment
{
    public decimal Amount { get; }
    protected Payment(decimal amount) => Amount = amount;

    public abstract decimal Fee();                      // no body: each type decides
    public decimal Total() => Amount + Fee();            // normal method, shared
    public override string ToString() => $"{GetType().Name}: {Amount} + fee {Fee()} = {Total()}";
}

public class UpiPayment : Payment
{
    public UpiPayment(decimal amount) : base(amount) { }
    public override decimal Fee() => 0m;
}

public class CardPayment : Payment
{
    public CardPayment(decimal amount) : base(amount) { }
    public override decimal Fee() => Math.Round(Amount * 0.02m, 2);
}

public class NetBankingPayment : Payment
{
    public NetBankingPayment(decimal amount) : base(amount) { }
    public override decimal Fee() => 10m;
}

Polymorphism in action

Payment[] payments =
{
    new UpiPayment(500m),
    new CardPayment(1000m),
    new NetBankingPayment(750m)
};

foreach (Payment p in payments)
    Console.WriteLine(p);

// var x = new Payment(10m);   // error CS0144: cannot create an instance of the abstract type

The decision of which Fee() to run is made at run time, by looking at the real object. This is called dynamic dispatch or late binding. The loop does not change when you add a new WalletPayment class tomorrow, which is the real benefit: new features without editing old, tested code.

Overriding versus hiding versus overloading

Checking and converting types

Payment p = new CardPayment(200m);
if (p is CardPayment card)
    Console.WriteLine($"Card fee: {card.Fee()}");

var maybe = p as UpiPayment;     // null if p is not a UpiPayment
Console.WriteLine(maybe is null);  // True

Common mistakes and fixes

• Not implementing an abstract method: error CS0534, the derived class does not implement the inherited abstract member. Add the override.
• Trying new on an abstract class: error CS0144. Create a concrete derived class.
• Calling an abstract or virtual method from the base constructor: the derived object is not fully set up yet, so it may see default values. Avoid it.
• Making a class abstract with no abstract members just to block new: a protected constructor or simply a normal class may be clearer.