Abstraction

In simple words#

Learning objectives#

• Explain abstraction and how it differs from encapsulation
• Define contracts with interfaces
• Share partial implementation with abstract classes
• Decide between an abstract class and an interface

Explanation#

Abstraction focuses on what an object does; encapsulation focuses on hiding how it stores its data. They work together.

An interface is a pure contract: a list of members a class promises to provide, with no state. A class can implement many interfaces.

An abstract class cannot be instantiated. It can contain both implemented methods (shared code) and abstract methods (which subclasses must implement). A class can inherit from only one class.

Code that depends on an abstraction (IPaymentGateway) instead of a concrete class (RazorpayGateway) is easier to test and to change.

Code example: Interface plus abstract base class#

1public interface INotifier
2{
3    Task SendAsync(string to, string message);
4}
5

6// Abstract class: shared logic + a step subclasses must provide
7public abstract class NotifierBase : INotifier
8{
9    public async Task SendAsync(string to, string message)
10    {
11        if (string.IsNullOrWhiteSpace(to)) throw new ArgumentException("Recipient required");
12        await DeliverAsync(to, message.Trim());
13        Console.WriteLine(
quot;[{GetType().Name}] sent to {to}");
14    }
15

16    protected abstract Task DeliverAsync(string to, string message);
17}
18

19public class EmailNotifier : NotifierBase
20{
21    protected override Task DeliverAsync(string to, string message) =>
22        Task.CompletedTask; // call an SMTP service here
23}
24

25public class SmsNotifier : NotifierBase
26{
27    protected override Task DeliverAsync(string to, string message) =>
28        Task.CompletedTask; // call an SMS API here
29}
30

31// The caller depends only on the abstraction.
32public class OrderService(INotifier notifier)
33{
34    public Task ConfirmAsync(string customer) =>
35        notifier.SendAsync(customer, "Your order is confirmed.");
36}
37

38// new NotifierBase();  // ✗ compile error: cannot create an instance of an abstract class

[EmailNotifier] sent to asha@example.com

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. INotifier is the contract: anything that can SendAsync.
2. NotifierBase implements the shared validation and logging once, then delegates the actual delivery to an abstract method.
3. EmailNotifier and SmsNotifier only fill in DeliverAsync — no duplicated validation.
4. OrderService receives an INotifier. It works with email, SMS, or a fake notifier in tests, without changing a line.
5. Trying to create a NotifierBase directly fails at compile time because it is abstract.

Real-world use case#

Common mistakes#

Best practices#

• Depend on interfaces at boundaries (databases, email, payments, clocks)
• Use abstract classes to share code between closely related types
• Keep interfaces small and focused
• Name interfaces after capabilities (INotifier, IRepository<T>)

Remember this#

Practice exercise#

1interface Shape { area(): number }
2class Circle implements Shape {
3  constructor(private r: number) {}
4  area() { return Math.PI * this.r ** 2; }
5}
6class Rectangle implements Shape {
7  constructor(private w: number, private h: number) {}
8  area() { return this.w * this.h; }
9}
10const totalArea = (shapes: Shape[]) => shapes.reduce((sum, s) => sum + s.area(), 0);

Mini quiz#

Want more? Practise all OOP Concepts MCQs · OOP Concepts interview questions

Related topics#

My notes#

Saved in this browser.