Abstract class vs interface: what are the differences, and when do you choose each?

Say it out loud, then check

One lease, both tools at work

A lease is loaded, billed and paid. Watch which part of the work the abstract class does, and which the interface does.

The story

1. Before

   BMW FS bills loans and leases through the abstract Contract. Its insurance partner's car policies came on a separate bill, and customers asked for one. Here are the two tempting fixes, and why both go wrong.

   ContractBalance, ApplyPayment()

   Policypremium only

   1/6Fix 1: make Policy inherit Contract. Then billing's list of Contract would take it.But a policy has no balance. Contract's constructor still wants one, so the code passes a fake 0.And it gets ApplyPayment(), which means nothing for a policy. One day someone calls it.Fix 2: a new abstract Billable above both. It builds, but it uses up each class's one base.Next ask: export contracts, not policies. Each class has only one base, so the chain gets deeper.Interfaces: each class implements only the abilities it has. Contract implements two, Policy one.

   BackPlayNext
2. Why it had to change

   A base class is a one-time choice: a class gets exactly one, and it brings all its data and its constructor along. Spending it on an ability like "can be billed" either drags fake data into types that don't have any, or leaves no room for the next ability.

3. How it works now

   With an interface, the billing loop is foreach (IBillable b in due) b.AmountDue();. Here is how .NET finds the right code for each object while the app runs, including a default body that no class wrote (the override walk for classes is on its page):

   Billingthe loop

   btype: IBillable

   Objectthe real one

   Its classwho fills each name

   has AmountDue? yes

   1/5At build time the compiler sees only IBillable b. It has AmountDue(), so the line builds.While the app runs, b holds a reference to an object. .NET follows it.The object says CarPolicy. .NET keeps a list per class: which method runs for each interface method.CarPolicy's map: AmountDue → its override. It runs and returns the premium.Then b.Summary(). No class wrote one, so the map points at the interface's default body.

   BackPlayNext
4. What we gained

   One bill for both families, with no fake balance on a policy. The next ability is one more interface, implemented only by the classes that have it. And a billing test can pass in any tiny test class that implements IBillable.

In the lending API

The contract family's base. It is abstract and implements IBillable; the comments mark what only an abstract class can do.

Only the key lines are shown; Deep walks the whole file.

The code, file by file

The billing types in the lending API: one interface, two abstract families, and the billing run that bills them together. Tap Next to walk the diagram with the code.

What they ask next

The follow-ups interviews really ask. Answer out loud, then tap to check.

• ReportedCan an abstract class have a constructor? How is it called?

  Yes. You can't call it with new, but every child calls it with : base(...) in its own constructor, and it runs first. It sets up the parent part of the child object and runs the shared checks. I make it protected, since only children can use it.

  protected Contract(string billTo,
    decimal balance, decimal monthlyAmount)
   
  // in Lease: Contract's runs first
  public Lease(...)
    : base(billTo, balance, monthlyAmount)

  Next questions, in Deep →Where this was reported
• ReportedTwo interfaces have the same default method. What happens?

  It builds. They are two different methods that share a name, and a class doesn't get either default as its own. So lease.Describe() doesn't compile, while ((IStatementLine)lease).Describe() runs that interface's body. If the class writes its own Describe(), both interfaces use it. The second live task below walks this code.

  class Lease : IStatementLine, IAuditLine { }
   
  lease.Describe();      // CS1061
  ((IStatementLine)lease)
    .Describe();       // "statement"
  ((IAuditLine)lease)
    .Describe();       // "audit"

  Next questions, in Deep →Where this was reported
• ReportedCan a class inherit an abstract class and implement interfaces at once? In what order?

  Yes: one base class, then any number of interfaces, base class first. class Lease : Contract, IExportable builds; class Lease : IExportable, Contract fails with CS1722: the rule is that the base class must come first, before any interface.

  public sealed class Lease
    : Contract, IExportable  // ok
   
  //  : IExportable, Contract  // CS1722

  Next questions, in Deep →Where this was reported

Follow-up tree

Answer, then open the next level. That is the order an interviewer digs in.

Reporteda candidate was asked Intervieweran interviewer asks it

• ReportedCan an abstract class have a constructor? How is it called?

  Yes. You can't call it with new, but every child calls it with : base(...) in its own constructor, and it runs first. It sets up the parent part of the child object and runs the shared checks. I make it protected, since only children can use it.

  protected Contract(string billTo,
    decimal balance, decimal monthlyAmount)
   
  // in Lease: Contract's runs first
  public Lease(...)
    : base(billTo, balance, monthlyAmount)

  Where this was reported
  • What if the child doesn't write : base(...)?

    The compiler calls the parent's constructor that takes no values. If the parent has none, like Contract, the child doesn't build: error CS7036, "no argument given". That is on purpose: no contract can be built without a balance.

  • Can an interface have a constructor or fields?

    No. An interface can't hold per-object data, so there is nothing to set up. Since C# 8 it can have static members and default method bodies, but never an instance field or a constructor.

• ReportedTwo interfaces have the same default method. What happens?

  It builds. They are two different methods that share a name, and a class doesn't get either default as its own. So lease.Describe() doesn't compile, while ((IStatementLine)lease).Describe() runs that interface's body. If the class writes its own Describe(), both interfaces use it. The second live task below walks this code.

  class Lease : IStatementLine, IAuditLine { }
   
  lease.Describe();      // CS1061
  ((IStatementLine)lease)
    .Describe();       // "statement"
  ((IAuditLine)lease)
    .Describe();       // "audit"

  Where this was reported
  • When does it fail to build?

    When both interfaces extend one parent interface and each gives a default for the same parent method. Then the class has two equally good answers for one method: error CS8705, "does not have a most specific implementation". The class must write its own.

  • Explain this lineWhat is explicit interface implementation?

    Writing a method as string IAuditLine.Describe() ties it to that one interface, so each interface can get its own answer. It is on the interface page.

• ReportedCan a class inherit an abstract class and implement interfaces at once? In what order?

  Yes: one base class, then any number of interfaces, base class first. class Lease : Contract, IExportable builds; class Lease : IExportable, Contract fails with CS1722: the rule is that the base class must come first, before any interface.

  public sealed class Lease
    : Contract, IExportable  // ok
   
  //  : IExportable, Contract  // CS1722

  Where this was reported
• InterviewerWhy not…With default methods, isn't an interface the same as an abstract class now?

  No. An interface still can't hold per-object data or have a constructor, so it can't keep anything valid. Default bodies were added so you can add a member to an interface without breaking every class that already implements it. I use them for that, not to share code. They need .NET Core 3.0 or later; old .NET Framework apps can't use them. The incident below is what happens without one.

  Microsoft Learn: default interface methods, for adding members safely
  • So which is easier to change later?

    Adding a normal method to an abstract class rarely breaks anyone: children just get it (unless one already has a method with that name). Adding a member without a body to an interface breaks every class that implemented it. Adding an abstract method breaks every child. So for types other teams build on, I add only bodies: normal methods, or default interface methods.

    Walk the incident →
• ReportedCan we achieve 100% abstraction?

  The textbook answer: an abstract class can be anywhere from 0 to 100% abstract, and an interface with no default bodies is 100%: it says only what, never how. I'd add the part that matters: the billing run depends on IBillable and knows nothing about how any class works, and that is what makes it easy to test and change.

  Infosys
• ReportedWhat is the difference between an abstract class and a normal class?

  A normal class can be built with new and every method has a body. An abstract class can't be built, and it may have methods with no body that children must write. I make a class abstract when a plain one would make no sense on its own, like a contract that is neither a loan nor a lease.

  HCLTech: an independent class vs an abstract class
• Why not…Should every class have an interface, like IPaymentService?

  No. I add one when something needs to swap the class: a test fake for something slow or external, or more than one real version. An interface for a class that has one version and is easy to test only adds a file to open. The interface page has the longer answer.

Production bugs, and how to tell them

Each one: what you see, why, the fix in code, and the line to say.

• The lease's own summary line never reaches the bill

  BMW FS call centre ticket:
  "My bill line doesn't mention the service plan.
  Is it still included?"
  (no exception; the Lease unit test passes)

  Cause

  IBillable gave Summary() a default body. Contract implements IBillable but never wrote Summary, so when .NET links each interface method to the code that runs it, Summary was linked to the interface's default, once, for every contract. Later Lease added its own plain public string Summary(). That is a separate method that only shares the name: Lease did not implement IBillable itself, so the link was never redone, and calls through IBillable still ran the default. No warning: Contract has no Summary for the compiler to say Lease is hiding.

  Fix

  Contract writes public virtual string Summary() with the default text, so IBillable.Summary is now linked to Contract's method, and that method is virtual. Lease overrides it, so the call follows the real object again. A test calls Summary() through an IBillable variable, the way billing does.

  BeforeBeforeAfterAfterSummaryTests.cs

  Diagram · step 3That was decided once, for all contracts: Contract wrote no Summary, so the default.Show diagram

  Unit testLease l; l.Summary()

  Leaseown Summary(): + plan

  Asha Rao: 460.​00 incl.​ service plan

  1public abstract class Contract : IBillable2{3 // ... no Summary() here4}

  Before · Contract.cs · line 1 · 1 of 1Implements IBillable and writes no Summary, so for every contract the interface uses its default body.

  BackNext file

  Say it

  It was a default interface method trap. The base class implemented the interface but never wrote that method, so the interface's default body was used for every child, and a child's method with the same name was never used through the interface, and the compiler gave no warning. The tests called it on a Lease variable, which hid it. We made the method virtual in the base and overrode it in the child, and the test now calls through the interface, the way production does.

Traps

• Don't sayAn interface can't have any code.SaySince C# 8 it can have default method bodies. It still can't hold per-object data or have a constructor.
• Don't sayUse an abstract class whenever classes share code.SayOnly when they are really one family and every child keeps the parent's promises. For shared code alone, composition.
• Don't sayInterfaces give C# multiple inheritance.SayA class implements many interfaces but inherits no data or constructor from them: many abilities, still one parent.

Traps

What should you say instead? Tap to check.

• Don't sayAn interface can't have any code.

  Say instead

  Since C# 8 it can have default method bodies. It still can't hold per-object data or have a constructor.

• Don't sayUse an abstract class whenever classes share code.

  Say instead

  Only when they are really one family and every child keeps the parent's promises. For shared code alone, composition.

• Don't sayInterfaces give C# multiple inheritance.

  Say instead

  A class implements many interfaces but inherits no data or constructor from them: many abilities, still one parent.