Interfaces

Define contracts with interfaces for flexible, maintainable code.

By Vishnu Darshan Sanku · Updated September 25, 2026

Video Explanation

Interfaces in OOP Explained

Interfaces define contracts that classes must follow. They specify what methods a class must implement without specifying how they should be implemented. This allows for polymorphism and loose coupling.

What are Interfaces?

An interface is a contract that specifies what methods a class must implement. It defines the “what” but not the “how”.

Why Use Interfaces?

Polymorphism - Different classes can be used interchangeably
Loose Coupling - Depend on abstractions, not concrete classes
Flexibility - Easy to swap implementations
Testability - Easy to create mock implementations
Multiple Inheritance - Classes can implement multiple interfaces

Python Interfaces

Python doesn’t have explicit interfaces like Java, but uses:

Abstract Base Classes (ABC) - Similar to interfaces
Protocols - Structural subtyping (duck typing)
ABC with @abstractmethod - Enforces method implementation

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2

3
class PaymentProcessor(ABC):
4
    """Interface-like abstract class"""
5

6
    @abstractmethod
7
    def process_payment(self, amount: float) -> bool:
8
        """Process a payment - must be implemented"""
9
        pass
10

11
    @abstractmethod
12
    def refund(self, transaction_id: str) -> bool:
13
        """Process a refund - must be implemented"""
14
        pass
15

16
    def validate_amount(self, amount: float) -> bool:
17
        """Concrete method - shared by all implementations"""
18
        return amount > 0
19

20
class CreditCardProcessor(PaymentProcessor):
21
    """Implements PaymentProcessor interface"""
22

23
    def __init__(self, api_key: str):
24
        self.api_key = api_key
25

26
    def process_payment(self, amount: float) -> bool:
27
        """Implement required method"""
28
        if not self.validate_amount(amount):
29
            return False
30
        print(f"Processing ${amount} via credit card")
31
        return True
32

33
    def refund(self, transaction_id: str) -> bool:
34
        """Implement required method"""
35
        print(f"Refunding transaction {transaction_id} via credit card")
36
        return True
37

38
class PayPalProcessor(PaymentProcessor):
39
    """Implements PaymentProcessor interface"""
40

41
    def process_payment(self, amount: float) -> bool:
42
        """Implement required method"""
43
        if not self.validate_amount(amount):
44
            return False
45
        print(f"Processing ${amount} via PayPal")
46
        return True
47

48
    def refund(self, transaction_id: str) -> bool:
49
        """Implement required method"""
50
        print(f"Refunding transaction {transaction_id} via PayPal")
51
        return True
52

53
# Usage - polymorphism
54
def checkout(processor: PaymentProcessor, amount: float):
55
    """Works with any PaymentProcessor implementation"""
56
    return processor.process_payment(amount)
57

58
credit_card = CreditCardProcessor("api_key_123")
59
paypal = PayPalProcessor()
60

61
checkout(credit_card, 100.0)  # Works
62
checkout(paypal, 100.0)       # Works

1
Processing $100.0 via credit card
2
Processing $100.0 via PayPal

1
from typing import Protocol
2

3
class PaymentProcessor(Protocol):
4
    """Protocol - structural subtyping"""
5

6
    def process_payment(self, amount: float) -> bool:
7
        """Process a payment"""
8
        ...
9

10
    def refund(self, transaction_id: str) -> bool:
11
        """Process a refund"""
12
        ...
13

14
class CreditCardProcessor:
15
    """Implements PaymentProcessor protocol"""
16

17
    def process_payment(self, amount: float) -> bool:
18
        print(f"Processing ${amount} via credit card")
19
        return True
20

21
    def refund(self, transaction_id: str) -> bool:
22
        print(f"Refunding transaction {transaction_id} via credit card")
23
        return True
24

25
# Protocol doesn't enforce - duck typing
26
def checkout(processor: PaymentProcessor, amount: float):
27
    return processor.process_payment(amount)
28

29
credit_card = CreditCardProcessor()
30
checkout(credit_card, 100.0)  # Works

1
// Interface definition
2
public interface PaymentProcessor {
3
    // Abstract methods (implicitly public and abstract)
4
    boolean processPayment(double amount);
5
    boolean refund(String transactionId);
6

7
    // Default method (Java 8+)
8
    default boolean validateAmount(double amount) {
9
        return amount > 0;
10
    }
11

12
    // Static method (Java 8+)
13
    static String getProcessorType() {
14
        return "Payment Processor";
15
    }
16
}
17

18
// Implementation
19
public class CreditCardProcessor implements PaymentProcessor {
20
    private String apiKey;
21

22
    public CreditCardProcessor(String apiKey) {
23
        this.apiKey = apiKey;
24
    }
25

26
    @Override
27
    public boolean processPayment(double amount) {
28
        if (!validateAmount(amount)) {
29
            return false;
30
        }
31
        System.out.println("Processing $" + amount + " via credit card");
32
        return true;
33
    }
34

35
    @Override
36
    public boolean refund(String transactionId) {
37
        System.out.println("Refunding transaction " + transactionId + " via credit card");
38
        return true;
39
    }
40
}
41

42
public class PayPalProcessor implements PaymentProcessor {
43
    @Override
44
    public boolean processPayment(double amount) {
45
        if (!validateAmount(amount)) {
46
            return false;
47
        }
48
        System.out.println("Processing $" + amount + " via PayPal");
49
        return true;
50
    }
51

52
    @Override
53
    public boolean refund(String transactionId) {
54
        System.out.println("Refunding transaction " + transactionId + " via PayPal");
55
        return true;
56
    }
57
}
58

59
// Usage - polymorphism
60
public class Main {
61
    public static void checkout(PaymentProcessor processor, double amount) {
62
        processor.processPayment(amount);
63
    }
64

65
    public static void main(String[] args) {
66
        PaymentProcessor creditCard = new CreditCardProcessor("api_key_123");
67
        PaymentProcessor paypal = new PayPalProcessor();
68

69
        checkout(creditCard, 100.0);  // Works
70
        checkout(paypal, 100.0);      // Works
71
    }
72
}

1
Processing $100.0 via credit card
2
Processing $100.0 via PayPal

1
// Interface definition
2
interface PaymentProcessor {
3
    processPayment(amount: number): boolean;
4
    refund(transactionId: string): boolean;
5

6
    // TypeScript doesn't have default methods in interfaces
7
    // but you can use abstract classes for that
8
}
9

10
// Implementation
11
class CreditCardProcessor implements PaymentProcessor {
12
    private apiKey: string;
13

14
    constructor(apiKey: string) {
15
        this.apiKey = apiKey;
16
    }
17

18
    processPayment(amount: number): boolean {
19
        if (!this.validateAmount(amount)) {
20
            return false;
21
        }
22
        console.log(`Processing $${amount} via credit card`);
23
        return true;
24
    }
25

26
    refund(transactionId: string): boolean {
27
        console.log(`Refunding transaction ${transactionId} via credit card`);
28
        return true;
29
    }
30

31
    private validateAmount(amount: number): boolean {
32
        return amount > 0;
33
    }
34
}
35

36
class PayPalProcessor implements PaymentProcessor {
37
    processPayment(amount: number): boolean {
38
        if (!this.validateAmount(amount)) {
39
            return false;
40
        }
41
        console.log(`Processing $${amount} via PayPal`);
42
        return true;
43
    }
44

45
    refund(transactionId: string): boolean {
46
        console.log(`Refunding transaction ${transactionId} via PayPal`);
47
        return true;
48
    }
49

50
    private validateAmount(amount: number): boolean {
51
        return amount > 0;
52
    }
53
}
54

55
// Usage - polymorphism
56
function checkout(processor: PaymentProcessor, amount: number): void {
57
    processor.processPayment(amount);
58
}
59

60
const creditCard = new CreditCardProcessor("api_key_123");
61
const paypal = new PayPalProcessor();
62

63
checkout(creditCard, 100.0);  // Works
64
checkout(paypal, 100.0);      // Works

1
Processing $100 via credit card
2
Processing $100 via PayPal

1
#include <iostream>
2
#include <string>
3

4
// Interface (abstract class in C++)
5
class PaymentProcessor {
6
public:
7
    // Pure virtual methods (abstract methods)
8
    virtual bool processPayment(double amount) = 0;
9
    virtual bool refund(const std::string& transactionId) = 0;
10

11
    // Concrete method (like default method)
12
    virtual bool validateAmount(double amount) const {
13
        return amount > 0;
14
    }
15

16
    virtual ~PaymentProcessor() = default;
17
};
18

19
// Implementation
20
class CreditCardProcessor : public PaymentProcessor {
21
private:
22
    std::string apiKey;
23

24
public:
25
    CreditCardProcessor(const std::string& apiKey) : apiKey(apiKey) {}
26

27
    bool processPayment(double amount) override {
28
        if (!validateAmount(amount)) {
29
            return false;
30
        }
31
        std::cout << "Processing $" << amount << " via credit card" << std::endl;
32
        return true;
33
    }
34

35
    bool refund(const std::string& transactionId) override {
36
        std::cout << "Refunding transaction " << transactionId << " via credit card" << std::endl;
37
        return true;
38
    }
39
};
40

41
class PayPalProcessor : public PaymentProcessor {
42
public:
43
    bool processPayment(double amount) override {
44
        if (!validateAmount(amount)) {
45
            return false;
46
        }
47
        std::cout << "Processing $" << amount << " via PayPal" << std::endl;
48
        return true;
49
    }
50

51
    bool refund(const std::string& transactionId) override {
52
        std::cout << "Refunding transaction " << transactionId << " via PayPal" << std::endl;
53
        return true;
54
    }
55
};
56

57
// Usage - polymorphism
58
void checkout(PaymentProcessor* processor, double amount) {
59
    processor->processPayment(amount);
60
}
61

62
int main() {
63
    CreditCardProcessor creditCard("api_key_123");
64
    PayPalProcessor paypal;
65

66
    checkout(&creditCard, 100.0);  // Works
67
    checkout(&paypal, 100.0);      // Works
68

69
    return 0;
70
}

1
Processing $100 via credit card
2
Processing $100 via PayPal

1
using System;
2

3
// Interface definition
4
public interface IPaymentProcessor
5
{
6
    bool ProcessPayment(double amount);
7
    bool Refund(string transactionId);
8
}
9

10
// Abstract class for shared functionality
11
public abstract class PaymentProcessorBase : IPaymentProcessor
12
{
13
    public abstract bool ProcessPayment(double amount);
14
    public abstract bool Refund(string transactionId);
15

16
    // Shared validation method
17
    protected bool ValidateAmount(double amount)
18
    {
19
        return amount > 0;
20
    }
21
}
22

23
// Implementation
24
public class CreditCardProcessor : PaymentProcessorBase
25
{
26
    private string apiKey;
27

28
    public CreditCardProcessor(string apiKey)
29
    {
30
        this.apiKey = apiKey;
31
    }
32

33
    public override bool ProcessPayment(double amount)
34
    {
35
        if (!ValidateAmount(amount))
36
        {
37
            return false;
38
        }
39
        Console.WriteLine($"Processing ${amount} via credit card");
40
        return true;
41
    }
42

43
    public override bool Refund(string transactionId)
44
    {
45
        Console.WriteLine($"Refunding transaction {transactionId} via credit card");
46
        return true;
47
    }
48
}
49

50
public class PayPalProcessor : PaymentProcessorBase
51
{
52
    public override bool ProcessPayment(double amount)
53
    {
54
        if (!ValidateAmount(amount))
55
        {
56
            return false;
57
        }
58
        Console.WriteLine($"Processing ${amount} via PayPal");
59
        return true;
60
    }
61

62
    public override bool Refund(string transactionId)
63
    {
64
        Console.WriteLine($"Refunding transaction {transactionId} via PayPal");
65
        return true;
66
    }
67
}
68

69
class Program
70
{
71
    static void Checkout(IPaymentProcessor processor, double amount)
72
    {
73
        processor.ProcessPayment(amount);
74
    }
75

76
    static void Main()
77
    {
78
        IPaymentProcessor creditCard = new CreditCardProcessor("api_key_123");
79
        IPaymentProcessor paypal = new PayPalProcessor();
80

81
        Checkout(creditCard, 100.0);  // Works
82
        Checkout(paypal, 100.0);      // Works
83
    }
84
}

1
Processing $100 via credit card
2
Processing $100 via PayPal

1
package main
2

3
import "fmt"
4

5
type PaymentProcessor interface {
6
  ProcessPayment(amount float64) bool
7
  Refund(transactionID string) bool
8
}
9

10
func validateAmount(amount float64) bool {
11
  return amount > 0
12
}
13

14
type CreditCardProcessor struct {
15
  APIKey string
16
}
17

18
func (c *CreditCardProcessor) ProcessPayment(amount float64) bool {
19
  if !validateAmount(amount) {
20
    return false
21
  }
22
  fmt.Printf("Processing $%g via credit card\n", amount)
23
  return true
24
}
25

26
func (*CreditCardProcessor) Refund(transactionID string) bool {
27
  fmt.Printf("Refunding transaction %s via credit card\n", transactionID)
28
  return true
29
}
30

31
type PayPalProcessor struct{}
32

33
func (*PayPalProcessor) ProcessPayment(amount float64) bool {
34
  if !validateAmount(amount) {
35
    return false
36
  }
37
  fmt.Printf("Processing $%g via PayPal\n", amount)
38
  return true
39
}
40

41
func (*PayPalProcessor) Refund(transactionID string) bool {
42
  fmt.Printf("Refunding transaction %s via PayPal\n", transactionID)
43
  return true
44
}
45

46
func checkout(p PaymentProcessor, amount float64) {
47
  p.ProcessPayment(amount)
48
}
49

50
func main() {
51
  cc := &CreditCardProcessor{APIKey: "api_key_123"}
52
  pp := &PayPalProcessor{}
53

54
  checkout(cc, 100.0)
55
  checkout(pp, 100.0)
56
}

1
Processing $100 via credit card
2
Processing $100 via PayPal

1
trait PaymentProcessor {
2
    fn process_payment(&self, amount: f64) -> bool;
3
    fn refund(&self, transaction_id: &str) -> bool;
4
}
5

6
fn validate_amount(amount: f64) -> bool {
7
    amount > 0.0
8
}
9

10
struct CreditCardProcessor {
11
    api_key: String,
12
}
13

14
impl PaymentProcessor for CreditCardProcessor {
15
    fn process_payment(&self, amount: f64) -> bool {
16
        if !validate_amount(amount) {
17
            return false;
18
        }
19
        println!("Processing ${} via credit card", amount);
20
        true
21
    }
22

23
    fn refund(&self, transaction_id: &str) -> bool {
24
        println!("Refunding transaction {} via credit card", transaction_id);
25
        true
26
    }
27
}
28

29
struct PayPalProcessor;
30

31
impl PaymentProcessor for PayPalProcessor {
32
    fn process_payment(&self, amount: f64) -> bool {
33
        if !validate_amount(amount) {
34
            return false;
35
        }
36
        println!("Processing ${} via PayPal", amount);
37
        true
38
    }
39

40
    fn refund(&self, transaction_id: &str) -> bool {
41
        println!("Refunding transaction {} via PayPal", transaction_id);
42
        true
43
    }
44
}
45

46
fn checkout(p: &dyn PaymentProcessor, amount: f64) {
47
    p.process_payment(amount);
48
}
49

50
fn main() {
51
    let cc = CreditCardProcessor {
52
        api_key: "api_key_123".into(),
53
    };
54
    let pp = PayPalProcessor;
55

56
    checkout(&cc, 100.0);
57
    checkout(&pp, 100.0);
58
}

1
Processing $100 via credit card
2
Processing $100 via PayPal

Multiple Interface Implementation

Classes can implement multiple interfaces:

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2

3
class Flyable(ABC):
4
    @abstractmethod
5
    def fly(self):
6
        pass
7

8
class Swimmable(ABC):
9
    @abstractmethod
10
    def swim(self):
11
        pass
12

13
class Duck(Flyable, Swimmable):
14
    """Duck implements multiple interfaces"""
15

16
    def fly(self):
17
        return "Flying through the air"
18

19
    def swim(self):
20
        return "Swimming in water"
21

22
    def quack(self):
23
        return "Quack!"
24

25
duck = Duck()
26
print(duck.fly())   # "Flying through the air"
27
print(duck.swim())  # "Swimming in water"
28
print(duck.quack()) # "Quack!"

1
Flying through the air
2
Swimming in water
3
Quack!

1
public interface Flyable {
2
    void fly();
3
}
4

5
public interface Swimmable {
6
    void swim();
7
}
8

9
public class Duck implements Flyable, Swimmable {
10
    @Override
11
    public void fly() {
12
        System.out.println("Flying through the air");
13
    }
14

15
    @Override
16
    public void swim() {
17
        System.out.println("Swimming in water");
18
    }
19

20
    public void quack() {
21
        System.out.println("Quack!");
22
    }
23
}
24

25
// Usage
26
public class Main {
27
    public static void main(String[] args) {
28
        Duck duck = new Duck();
29
        duck.fly();   // "Flying through the air"
30
        duck.swim();  // "Swimming in water"
31
        duck.quack(); // "Quack!"
32
    }
33
}

1
Flying through the air
2
Swimming in water
3
Quack!

1
interface Flyable {
2
    fly(): void;
3
}
4

5
interface Swimmable {
6
    swim(): void;
7
}
8

9
class Duck implements Flyable, Swimmable {
10
    fly(): void {
11
        console.log("Flying through the air");
12
    }
13

14
    swim(): void {
15
        console.log("Swimming in water");
16
    }
17

18
    quack(): void {
19
        console.log("Quack!");
20
    }
21
}
22

23
const duck = new Duck();
24
duck.fly();   // "Flying through the air"
25
duck.swim();  // "Swimming in water"
26
duck.quack(); // "Quack!"

1
Flying through the air
2
Swimming in water
3
Quack!

1
#include <iostream>
2

3
// Abstract classes act as interfaces in C++
4
class Flyable {
5
public:
6
    virtual void fly() const = 0;
7
    virtual ~Flyable() = default;
8
};
9

10
class Swimmable {
11
public:
12
    virtual void swim() const = 0;
13
    virtual ~Swimmable() = default;
14
};
15

16
// Duck implements multiple interfaces
17
class Duck : public Flyable, public Swimmable {
18
public:
19
    void fly() const override {
20
        std::cout << "Flying through the air" << std::endl;
21
    }
22

23
    void swim() const override {
24
        std::cout << "Swimming in water" << std::endl;
25
    }
26

27
    void quack() const {
28
        std::cout << "Quack!" << std::endl;
29
    }
30
};
31

32
int main() {
33
    Duck duck;
34
    duck.fly();   // "Flying through the air"
35
    duck.swim();  // "Swimming in water"
36
    duck.quack(); // "Quack!"
37

38
    return 0;
39
}

1
Flying through the air
2
Swimming in water
3
Quack!

1
using System;
2

3
public interface IFlyable
4
{
5
    void Fly();
6
}
7

8
public interface ISwimmable
9
{
10
    void Swim();
11
}
12

13
public class Duck : IFlyable, ISwimmable
14
{
15
    public void Fly()
16
    {
17
        Console.WriteLine("Flying through the air");
18
    }
19

20
    public void Swim()
21
    {
22
        Console.WriteLine("Swimming in water");
23
    }
24

25
    public void Quack()
26
    {
27
        Console.WriteLine("Quack!");
28
    }
29
}
30

31
class Program
32
{
33
    static void Main()
34
    {
35
        Duck duck = new Duck();
36
        duck.Fly();   // "Flying through the air"
37
        duck.Swim();  // "Swimming in water"
38
        duck.Quack(); // "Quack!"
39
    }
40
}

1
Flying through the air
2
Swimming in water
3
Quack!

1
package main
2

3
import "fmt"
4

5
type Flyable interface{ Fly() }
6
type Swimmable interface{ Swim() }
7

8
type Duck struct{}
9

10
func (*Duck) Fly() {
11
  fmt.Println("Flying through the air")
12
}
13

14
func (*Duck) Swim() {
15
  fmt.Println("Swimming in water")
16
}
17

18
func (*Duck) Quack() {
19
  fmt.Println("Quack!")
20
}
21

22
var (
23
  _ Flyable   = (*Duck)(nil)
24
  _ Swimmable = (*Duck)(nil)
25
)
26

27
func main() {
28
  duck := &Duck{}
29
  duck.Fly()
30
  duck.Swim()
31
  duck.Quack()
32
}

1
Flying through the air
2
Swimming in water
3
Quack!

1
trait Flyable {
2
    fn fly(&self);
3
}
4

5
trait Swimmable {
6
    fn swim(&self);
7
}
8

9
struct Duck;
10

11
impl Flyable for Duck {
12
    fn fly(&self) {
13
        println!("Flying through the air");
14
    }
15
}
16

17
impl Swimmable for Duck {
18
    fn swim(&self) {
19
        println!("Swimming in water");
20
    }
21
}
22

23
impl Duck {
24
    fn quack(&self) {
25
        println!("Quack!");
26
    }
27
}
28

29
fn main() {
30
    let duck = Duck;
31
    duck.fly();
32
    duck.swim();
33
    duck.quack();
34
}

1
Flying through the air
2
Swimming in water
3
Quack!

Real-World Example: Notification System

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2

3
class NotificationService(ABC):
4
    """Interface for notification services"""
5

6
    @abstractmethod
7
    def send(self, recipient: str, message: str) -> bool:
8
        """Send notification - must be implemented"""
9
        pass
10

11
    @abstractmethod
12
    def can_send(self, recipient: str) -> bool:
13
        """Check if notification can be sent"""
14
        pass
15

16
class EmailService(NotificationService):
17
    """Email notification implementation"""
18

19
    def send(self, recipient: str, message: str) -> bool:
20
        if not self.can_send(recipient):
21
            return False
22
        print(f"Sending email to {recipient}: {message}")
23
        return True
24

25
    def can_send(self, recipient: str) -> bool:
26
        return "@" in recipient
27

28
class SMSService(NotificationService):
29
    """SMS notification implementation"""
30

31
    def send(self, recipient: str, message: str) -> bool:
32
        if not self.can_send(recipient):
33
            return False
34
        print(f"Sending SMS to {recipient}: {message[:50]}...")
35
        return True
36

37
    def can_send(self, recipient: str) -> bool:
38
        return recipient.startswith("+")
39

40
class NotificationManager:
41
    """Manages multiple notification services"""
42

43
    def __init__(self):
44
        self.services: list[NotificationService] = []
45

46
    def add_service(self, service: NotificationService):
47
        """Add a notification service"""
48
        self.services.append(service)
49

50
    def broadcast(self, recipient: str, message: str):
51
        """Send message through all services"""
52
        for service in self.services:
53
            if service.can_send(recipient):
54
                service.send(recipient, message)
55

56
# Usage
57
manager = NotificationManager()
58
manager.add_service(EmailService())
59
manager.add_service(SMSService())
60

61
manager.broadcast("[email protected]", "Your order has shipped!")
62
manager.broadcast("+1234567890", "Your order has shipped!")

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
public interface NotificationService {
2
    boolean send(String recipient, String message);
3
    boolean canSend(String recipient);
4
}
5

6
public class EmailService implements NotificationService {
7
    @Override
8
    public boolean send(String recipient, String message) {
9
        if (!canSend(recipient)) {
10
            return false;
11
        }
12
        System.out.println("Sending email to " + recipient + ": " + message);
13
        return true;
14
    }
15

16
    @Override
17
    public boolean canSend(String recipient) {
18
        return recipient.contains("@");
19
    }
20
}
21

22
public class SMSService implements NotificationService {
23
    @Override
24
    public boolean send(String recipient, String message) {
25
        if (!canSend(recipient)) {
26
            return false;
27
        }
28
        System.out.println("Sending SMS to " + recipient + ": " + message.substring(0, Math.min(50, message.length())) + "...");
29
        return true;
30
    }
31

32
    @Override
33
    public boolean canSend(String recipient) {
34
        return recipient.startsWith("+");
35
    }
36
}
37

38
public class NotificationManager {
39
    private java.util.List<NotificationService> services;
40

41
    public NotificationManager() {
42
        this.services = new java.util.ArrayList<>();
43
    }
44

45
    public void addService(NotificationService service) {
46
        this.services.add(service);
47
    }
48

49
    public void broadcast(String recipient, String message) {
50
        for (NotificationService service : services) {
51
            if (service.canSend(recipient)) {
52
                service.send(recipient, message);
53
            }
54
        }
55
    }
56
}
57

58
// Usage
59
public class Main {
60
    public static void main(String[] args) {
61
        NotificationManager manager = new NotificationManager();
62
        manager.addService(new EmailService());
63
        manager.addService(new SMSService());
64

65
        manager.broadcast("[email protected]", "Your order has shipped!");
66
        manager.broadcast("+1234567890", "Your order has shipped!");
67
    }
68
}

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
// Interface for notification services
2
interface NotificationService {
3
    send(recipient: string, message: string): boolean;
4
    canSend(recipient: string): boolean;
5
}
6

7
class EmailService implements NotificationService {
8
    send(recipient: string, message: string): boolean {
9
        if (!this.canSend(recipient)) {
10
            return false;
11
        }
12
        console.log(`Sending email to ${recipient}: ${message}`);
13
        return true;
14
    }
15

16
    canSend(recipient: string): boolean {
17
        return recipient.includes("@");
18
    }
19
}
20

21
class SMSService implements NotificationService {
22
    send(recipient: string, message: string): boolean {
23
        if (!this.canSend(recipient)) {
24
            return false;
25
        }
26
        console.log(`Sending SMS to ${recipient}: ${message.substring(0, 50)}...`);
27
        return true;
28
    }
29

30
    canSend(recipient: string): boolean {
31
        return recipient.startsWith("+");
32
    }
33
}
34

35
class NotificationManager {
36
    private services: NotificationService[] = [];
37

38
    addService(service: NotificationService): void {
39
        this.services.push(service);
40
    }
41

42
    broadcast(recipient: string, message: string): void {
43
        for (const service of this.services) {
44
            if (service.canSend(recipient)) {
45
                service.send(recipient, message);
46
            }
47
        }
48
    }
49
}
50

51
// Usage
52
const manager = new NotificationManager();
53
manager.addService(new EmailService());
54
manager.addService(new SMSService());
55

56
manager.broadcast("[email protected]", "Your order has shipped!");
57
manager.broadcast("+1234567890", "Your order has shipped!");

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <memory>
5

6
// Interface for notification services
7
class NotificationService {
8
public:
9
    virtual bool send(const std::string& recipient, const std::string& message) = 0;
10
    virtual bool canSend(const std::string& recipient) const = 0;
11
    virtual ~NotificationService() = default;
12
};
13

14
class EmailService : public NotificationService {
15
public:
16
    bool send(const std::string& recipient, const std::string& message) override {
17
        if (!canSend(recipient)) {
18
            return false;
19
        }
20
        std::cout << "Sending email to " << recipient << ": " << message << std::endl;
21
        return true;
22
    }
23

24
    bool canSend(const std::string& recipient) const override {
25
        return recipient.find("@") != std::string::npos;
26
    }
27
};
28

29
class SMSService : public NotificationService {
30
public:
31
    bool send(const std::string& recipient, const std::string& message) override {
32
        if (!canSend(recipient)) {
33
            return false;
34
        }
35
        std::string truncated = message.length() > 50 ? message.substr(0, 50) + "..." : message;
36
        std::cout << "Sending SMS to " << recipient << ": " << truncated << std::endl;
37
        return true;
38
    }
39

40
    bool canSend(const std::string& recipient) const override {
41
        return recipient.rfind("+", 0) == 0;
42
    }
43
};
44

45
class NotificationManager {
46
private:
47
    std::vector<std::shared_ptr<NotificationService>> services;
48

49
public:
50
    void addService(std::shared_ptr<NotificationService> service) {
51
        services.push_back(service);
52
    }
53

54
    void broadcast(const std::string& recipient, const std::string& message) {
55
        for (const auto& service : services) {
56
            if (service->canSend(recipient)) {
57
                service->send(recipient, message);
58
            }
59
        }
60
    }
61
};
62

63
int main() {
64
    NotificationManager manager;
65
    manager.addService(std::make_shared<EmailService>());
66
    manager.addService(std::make_shared<SMSService>());
67

68
    manager.broadcast("[email protected]", "Your order has shipped!");
69
    manager.broadcast("+1234567890", "Your order has shipped!");
70

71
    return 0;
72
}

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
using System;
2
using System.Collections.Generic;
3

4
// Interface for notification services
5
public interface INotificationService
6
{
7
    bool Send(string recipient, string message);
8
    bool CanSend(string recipient);
9
}
10

11
public class EmailService : INotificationService
12
{
13
    public bool Send(string recipient, string message)
14
    {
15
        if (!CanSend(recipient))
16
        {
17
            return false;
18
        }
19
        Console.WriteLine($"Sending email to {recipient}: {message}");
20
        return true;
21
    }
22

23
    public bool CanSend(string recipient)
24
    {
25
        return recipient.Contains("@");
26
    }
27
}
28

29
public class SMSService : INotificationService
30
{
31
    public bool Send(string recipient, string message)
32
    {
33
        if (!CanSend(recipient))
34
        {
35
            return false;
36
        }
37
        string truncated = message.Length > 50 ? message.Substring(0, 50) + "..." : message;
38
        Console.WriteLine($"Sending SMS to {recipient}: {truncated}");
39
        return true;
40
    }
41

42
    public bool CanSend(string recipient)
43
    {
44
        return recipient.StartsWith("+");
45
    }
46
}
47

48
public class NotificationManager
49
{
50
    private List<INotificationService> services = new List<INotificationService>();
51

52
    public void AddService(INotificationService service)
53
    {
54
        services.Add(service);
55
    }
56

57
    public void Broadcast(string recipient, string message)
58
    {
59
        foreach (var service in services)
60
        {
61
            if (service.CanSend(recipient))
62
            {
63
                service.Send(recipient, message);
64
            }
65
        }
66
    }
67
}
68

69
class Program
70
{
71
    static void Main()
72
    {
73
        NotificationManager manager = new NotificationManager();
74
        manager.AddService(new EmailService());
75
        manager.AddService(new SMSService());
76

77
        manager.Broadcast("[email protected]", "Your order has shipped!");
78
        manager.Broadcast("+1234567890", "Your order has shipped!");
79
    }
80
}

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
package main
2

3
import (
4
  "fmt"
5
  "strings"
6
)
7

8
type NotificationService interface {
9
  Send(recipient, message string) bool
10
  CanSend(recipient string) bool
11
}
12

13
type EmailService struct{}
14

15
func (e *EmailService) Send(recipient, message string) bool {
16
  if !e.CanSend(recipient) {
17
    return false
18
  }
19
  fmt.Printf("Sending email to %s: %s\n", recipient, message)
20
  return true
21
}
22

23
func (*EmailService) CanSend(recipient string) bool {
24
  return strings.Contains(recipient, "@")
25
}
26

27
type SMSService struct{}
28

29
func (s *SMSService) Send(recipient, message string) bool {
30
  if !s.CanSend(recipient) {
31
    return false
32
  }
33
  if len(message) > 50 {
34
    message = message[:50] + "..."
35
  }
36
  fmt.Printf("Sending SMS to %s: %s\n", recipient, message)
37
  return true
38
}
39

40
func (*SMSService) CanSend(recipient string) bool {
41
  return strings.HasPrefix(recipient, "+")
42
}
43

44
type NotificationManager struct {
45
  Services []NotificationService
46
}
47

48
func (m *NotificationManager) AddService(s NotificationService) {
49
  m.Services = append(m.Services, s)
50
}
51

52
func (m *NotificationManager) Broadcast(recipient, message string) {
53
  for _, s := range m.Services {
54
    if s.CanSend(recipient) {
55
      s.Send(recipient, message)
56
    }
57
  }
58
}
59

60
func main() {
61
  m := &NotificationManager{}
62
  m.AddService(&EmailService{})
63
  m.AddService(&SMSService{})
64

65
  m.Broadcast("[email protected]", "Your order has shipped!")
66
  m.Broadcast("+1234567890", "Your order has shipped!")
67
}

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

1
trait NotificationService {
2
    fn send(&self, recipient: &str, message: &str) -> bool;
3
    fn can_send(&self, recipient: &str) -> bool;
4
}
5

6
struct EmailService;
7

8
impl NotificationService for EmailService {
9
    fn send(&self, recipient: &str, message: &str) -> bool {
10
        if !self.can_send(recipient) {
11
            return false;
12
        }
13
        println!("Sending email to {}: {}", recipient, message);
14
        true
15
    }
16

17
    fn can_send(&self, recipient: &str) -> bool {
18
        recipient.contains('@')
19
    }
20
}
21

22
struct SmsService;
23

24
impl NotificationService for SmsService {
25
    fn send(&self, recipient: &str, message: &str) -> bool {
26
        if !self.can_send(recipient) {
27
            return false;
28
        }
29
        let message = if message.len() > 50 {
30
            format!("{}...", &message[..50])
31
        } else {
32
            message.to_string()
33
        };
34
        println!("Sending SMS to {}: {}", recipient, message);
35
        true
36
    }
37

38
    fn can_send(&self, recipient: &str) -> bool {
39
        recipient.starts_with('+')
40
    }
41
}
42

43
struct NotificationManager {
44
    services: Vec<Box<dyn NotificationService>>,
45
}
46

47
impl NotificationManager {
48
    fn add_service(&mut self, service: Box<dyn NotificationService>) {
49
        self.services.push(service);
50
    }
51

52
    fn broadcast(&self, recipient: &str, message: &str) {
53
        for service in &self.services {
54
            if service.can_send(recipient) {
55
                service.send(recipient, message);
56
            }
57
        }
58
    }
59
}
60

61
fn main() {
62
    let mut manager = NotificationManager { services: vec![] };
63
    manager.add_service(Box::new(EmailService));
64
    manager.add_service(Box::new(SmsService));
65

66
    manager.broadcast("[email protected]", "Your order has shipped!");
67
    manager.broadcast("+1234567890", "Your order has shipped!");
68
}

1
Sending email to [email protected]: Your order has shipped!
2
Sending SMS to +1234567890: Your order has shipped!

Visual Representation

PaymentProcessor interface with processPayment and refund, implemented by CreditCardProcessor and PayPalProcessor

Key Takeaways

When to Use Interfaces

Use interfaces when:

You want to define a contract that multiple classes can follow
You need polymorphism - treat different classes the same way
You want loose coupling - depend on abstractions
You need multiple inheritance of behavior (not state)
You want to make code more testable with mock implementations

Examples:

Payment processors (different payment methods)
Notification services (email, SMS, push)
Data access layers (different databases)
Storage services (local, cloud, database)
Authentication providers (OAuth, JWT, etc.)

💡 Time to Practice!

Now that you understand the concepts, put them into practice with our interactive playground. Build UML diagrams, write code, and get AI-powered feedback.

Browse All Problems

Share feedback or report an issue

Interfaces

Interfaces in OOP Explained

What are Interfaces?

Why Use Interfaces?

Python Interfaces

Multiple Interface Implementation

Real-World Example: Notification System

Visual Representation

Key Takeaways

When to Use Interfaces

Follow a Structured Learning Path

💡 Time to Practice!