oop-polymorphism

name	oop-polymorphism
user-invocable	false
description	Use when implementing polymorphism and interfaces in object-oriented design. Use when creating flexible, extensible systems with interchangeable components.
allowed-tools	["Bash","Read"]

OOP Polymorphism

Master polymorphism to create flexible, extensible object-oriented systems. This skill focuses on understanding and applying polymorphic behavior through interfaces, abstract classes, and runtime type substitution.

Understanding Polymorphism

Polymorphism allows objects of different types to be treated uniformly through a common interface. It enables writing code that works with abstractions rather than concrete implementations.

Interface-Based Polymorphism in Java

// Common interface for all payment methods
public interface PaymentMethod {
    PaymentResult process(BigDecimal amount);
    boolean isValid();
    String getDisplayName();
}

// Concrete implementations
public class CreditCard implements PaymentMethod {
    private final String cardNumber;
    private final String cardholderName;
    private final String expiryDate;
    private final String cvv;

    public CreditCard(String cardNumber, String cardholderName, String expiryDate, String cvv) {
        this.cardNumber = cardNumber;
        this.cardholderName = cardholderName;
        this.expiryDate = expiryDate;
        this.cvv = cvv;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        if (!isValid()) {
            return PaymentResult.failed("Invalid credit card");
        }

        // Credit card processing logic
        String transactionId = UUID.randomUUID().toString();
        System.out.println("Processing $" + amount + " via credit card ending in " +
            cardNumber.substring(cardNumber.length() - 4));

        return PaymentResult.success(transactionId, amount);
    }

    @Override
    public boolean isValid() {
        return cardNumber != null &&
               cardNumber.length() == 16 &&
               !isExpired(expiryDate);
    }

    @Override
    public String getDisplayName() {
        return "Credit Card ending in " + cardNumber.substring(cardNumber.length() - 4);
    }

    private boolean isExpired(String expiryDate) {
        // Expiry date validation logic
        return false;
    }
}

public class PayPal implements PaymentMethod {
    private final String email;
    private final String password;

    public PayPal(String email, String password) {
        this.email = email;
        this.password = password;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        if (!isValid()) {
            return PaymentResult.failed("Invalid PayPal credentials");
        }

        String transactionId = UUID.randomUUID().toString();
        System.out.println("Processing $" + amount + " via PayPal account " + email);

        return PaymentResult.success(transactionId, amount);
    }

    @Override
    public boolean isValid() {
        return email != null && email.contains("@") && password != null;
    }

    @Override
    public String getDisplayName() {
        return "PayPal (" + email + ")";
    }
}

public class BankTransfer implements PaymentMethod {
    private final String accountNumber;
    private final String routingNumber;
    private final String accountHolderName;

    public BankTransfer(String accountNumber, String routingNumber, String accountHolderName) {
        this.accountNumber = accountNumber;
        this.routingNumber = routingNumber;
        this.accountHolderName = accountHolderName;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        if (!isValid()) {
            return PaymentResult.failed("Invalid bank account");
        }

        String transactionId = UUID.randomUUID().toString();
        System.out.println("Processing $" + amount + " via bank transfer from " + accountHolderName);

        return PaymentResult.success(transactionId, amount);
    }

    @Override
    public boolean isValid() {
        return accountNumber != null &&
               routingNumber != null &&
               accountNumber.length() > 0;
    }

    @Override
    public String getDisplayName() {
        return "Bank Account (" + accountHolderName + ")";
    }
}

// Polymorphic usage
public class PaymentProcessor {
    private final List<PaymentMethod> paymentMethods;

    public PaymentProcessor() {
        this.paymentMethods = new ArrayList<>();
    }

    public void addPaymentMethod(PaymentMethod method) {
        paymentMethods.add(method);
    }

    public PaymentResult processPayment(BigDecimal amount) {
        // Try each payment method until one succeeds
        for (PaymentMethod method : paymentMethods) {
            if (method.isValid()) {
                System.out.println("Attempting payment with " + method.getDisplayName());
                PaymentResult result = method.process(amount);

                if (result.isSuccess()) {
                    return result;
                }
            }
        }

        return PaymentResult.failed("No valid payment method available");
    }

    public List<String> getAvailablePaymentMethods() {
        return paymentMethods.stream()
            .filter(PaymentMethod::isValid)
            .map(PaymentMethod::getDisplayName)
            .collect(Collectors.toList());
    }
}

// Usage - polymorphism in action
PaymentProcessor processor = new PaymentProcessor();
processor.addPaymentMethod(new CreditCard("1234567890123456", "John Doe", "12/25", "123"));
processor.addPaymentMethod(new PayPal("[e-mail]", "secret"));
processor.addPaymentMethod(new BankTransfer("9876543210", "123456789", "John Doe"));

PaymentResult result = processor.processPayment(new BigDecimal("99.99"));

Protocol-Based Polymorphism in Python

from typing import Protocol, List, Optional
from abc import ABC, abstractmethod
from dataclasses import dataclass
import json

# Protocol defines the interface (structural typing)
class Serializable(Protocol):
    """Protocol for objects that can be serialized."""

    def to_dict(self) -> dict:
        """Convert to dictionary."""
        ...

    def to_json(self) -> str:
        """Convert to JSON string."""
        ...

# Another protocol
class Identifiable(Protocol):
    """Protocol for objects with an ID."""

    @property
    def id(self) -> str:
        """Get unique identifier."""
        ...

# Concrete implementations
@dataclass
class User:
    """User implementation with both protocols."""

    _id: str
    username: str
    email: str
    age: int

    @property
    def id() -> :
         ._

     () -> :
         {
            : ._,
            : .username,
            : .email,
            : .age
        }

     () -> :
         json.dumps(.to_dict())


 :
    

    _: 
    name: 
    price: 
    category: 


     () -> :
         ._

     () -> :
         {
            : ._,
            : .name,
            : .price,
            : .category
        }

     () -> :
         json.dumps(.to_dict())


 :
    

    _: 
    user_id: 
    items: []
    total: 


     () -> :
         ._

     () -> :
         {
            : ._,
            : .user_id,
            : .items,
            : .total
        }

     () -> :
         json.dumps(.to_dict())


 () -> :
    
     (filename, )  f:
        f.write(obj.to_json())

 () -> :
    
     obj.

 () -> :
    
     json.dumps([obj.to_dict()  obj  objects])


user = User(, , , )
product = Product(, , , )
order = Order(, , [], )

save_to_file(user, )
save_to_file(product, )

all_objects = [user, product, order]
batch_json = serialize_batch(all_objects)

Abstract Base Classes in Python

from abc import ABC, abstractmethod
from typing import List, Dict, Any
from datetime import datetime

# Abstract base class defining contract
class DataStore(ABC):
    """Abstract base class for data storage."""

    @abstractmethod
    def connect(self) -> None:
        """Establish connection to data store."""
        pass

    @abstractmethod
    def disconnect(self) -> None:
        """Close connection to data store."""
        pass

    @abstractmethod
    def save(self, key: str, value: Any) -> bool:
        """Save value with given key."""
        pass

    @abstractmethod
    def load(self, key: str) -> Optional[Any]:
        """Load value for given key."""
        pass

    @abstractmethod
    def delete(self, key: str) -> :
        
        


     () -> []:
        
        

    
     () -> :
        
         .load(key)   

     () -> :
        
        count = 
         key, value  items.items():
             .save(key, value):
                count += 
         count


 ():
    

     ():
        ._data: [, ] = {}
        ._connected = 

     () -> :
        ._connected = 
        ()

     () -> :
        ._connected = 
        ()

     () -> :
          ._connected:
             RuntimeError()
        ._data[key] = value
         

     () -> []:
          ._connected:
             RuntimeError()
         ._data.get(key)

     () -> :
          ._connected:
             RuntimeError()
         key  ._data:
             ._data[key]
             
         

     () -> []:
          ._connected:
             RuntimeError()
         (._data.keys())


 ():
    

     ():
        ._directory = directory
        ._connected = 

     () -> :
         os
        os.makedirs(._directory, exist_ok=)
        ._connected = 
        ()

     () -> :
        ._connected = 
        ()

     () -> :
          ._connected:
             RuntimeError()

         json
        filepath = os.path.join(._directory, )
        :
             (filepath, )  f:
                json.dump(value, f)
             
         Exception  e:
            ()
             

     () -> []:
          ._connected:
             RuntimeError()

         json
        filepath = os.path.join(._directory, )
        :
             (filepath, )  f:
                 json.load(f)
         FileNotFoundError:
             
         Exception  e:
            ()
             

     () -> :
          ._connected:
             RuntimeError()

         os
        filepath = os.path.join(._directory, )
        :
            os.remove(filepath)
             
         FileNotFoundError:
             

     () -> []:
          ._connected:
             RuntimeError()

         os
         [
            f[:-]  f  os.listdir(._directory)
             f.endswith()
        ]


 :
    

     ():
        ._store = store

     ():
        ._store.connect()
         

     ():
        ._store.disconnect()

     () -> :
        
        count = 
         key  source_store.list_keys():
            value = source_store.load(key)
             value     ._store.save(key, value):
                count += 
         count

     () -> :
        
        count = 
         key  ._store.list_keys():
            value = ._store.load(key)
             value     target_store.save(key, value):
                count += 
         count


 DataManager(MemoryStore())  manager:
    manager._store.save(, {: , : })

 DataManager(FileStore())  manager:
    manager._store.save(, {: , : })

TypeScript Polymorphism

// Interface-based polymorphism
interface Logger {
  log(message: string, level: string): void;
  flush(): void;
}

interface Formatter {
  format(message: string, level: string): string;
}

// Concrete implementations
class ConsoleLogger implements Logger {
  private formatter: Formatter;

  constructor(formatter: Formatter) {
    this.formatter = formatter;
  }

  log(message: string, level: string): void {
    const formatted = this.formatter.format(message, level);
    console.log(formatted);
  }

  flush(): void {
    // Console logs immediately, nothing to flush
  }
}

class FileLogger implements  {
   : ;
   : [] = [];
    : ;

  () {
    . = filename;
    . = formatter;
  }

  (: , : ):  {
     formatted = ..(message, level);
    ..(formatted);

     (.. >= ) {
      .();
    }
  }

  ():  {
     (.. === ) ;

    
     content = ..();
    .(, content);
    . = [];
  }
}

    {
  (: , : ):  {
     .({
      message,
      level,
      :  ().()
    });
  }
}

    {
  (: , : ):  {
     timestamp =  ().();
     ;
  }
}


    {
   : [] = [];

  (: ):  {
    ..(logger);
  }

  (: , : ):  {
     ( logger  .) {
      logger.(message, level);
    }
  }

  ():  {
     ( logger  .) {
      logger.();
    }
  }
}


  {
   : ;

  () {
    . = logger;
  }

  ():  {
    ..(, );
    .();
    ..(, );
    ..();
  }

   ():  {
    ..(, );
    
  }
}


 jsonFormatter =  ();
 textFormatter =  ();

 consoleLogger =  (textFormatter);
 fileLogger =  (, jsonFormatter);

 multiLogger =  ();
multiLogger.(consoleLogger);
multiLogger.(fileLogger);


 app =  (multiLogger);
app.();

C# Polymorphism with Interfaces

// Interface for notification services
public interface INotificationService
{
    Task SendAsync(string recipient, string subject, string body);
    bool IsAvailable();
    string GetServiceName();
}

// Concrete implementations
public class EmailNotificationService : INotificationService
{
    private readonly string _smtpServer;
    private readonly int _port;
    private readonly string _username;
    private readonly string _password;

    public EmailNotificationService(string smtpServer, int port, string username, string password)
    {
        _smtpServer = smtpServer;
        _port = port;
        _username = username;
        _password = password;
    }

    public async Task SendAsync(string recipient, string subject, string body)
    {
        if (!IsAvailable())
            throw  InvalidOperationException();

        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine();

        
         Task.Delay();
    }

    
    {
         !.IsNullOrEmpty(_smtpServer);
    }

    
    {
         ;
    }
}

   : 
{
       _apiKey;
       _phoneNumber;

    
    {
        _apiKey = apiKey;
        _phoneNumber = phoneNumber;
    }

    
    {
         (!IsAvailable())
              InvalidOperationException();

        Console.WriteLine();
        Console.WriteLine();

         Task.Delay();
    }

    
    {
         !.IsNullOrEmpty(_apiKey);
    }

    
    {
         ;
    }
}

   : 
{
       _appId;
       _apiKey;

    
    {
        _appId = appId;
        _apiKey = apiKey;
    }

    
    {
         (!IsAvailable())
              InvalidOperationException();

        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine();

         Task.Delay();
    }

    
    {
         !.IsNullOrEmpty(_appId) && !.IsNullOrEmpty(_apiKey);
    }

    
    {
         ;
    }
}


  
{
      List<INotificationService> _services;

    
    {
        _services =  List<INotificationService>();
    }

    
    {
        _services.Add(service);
    }

    
    {
         availableServices = _services.Where(s => s.IsAvailable()).ToList();

         (!availableServices.Any())
        {
              InvalidOperationException();
        }

        Console.WriteLine();

         tasks = availableServices.Select(service =>
            NotifyWithServiceAsync(service, recipient, subject, body)
        );

         Task.WhenAll(tasks);
    }

    
    {
        
        {
             service.SendAsync(recipient, subject, body);
            Console.WriteLine();
        }
         (Exception ex)
        {
            Console.WriteLine();
        }
    }

    
    {
         _services
            .Where(s => s.IsAvailable())
            .Select(s => s.GetServiceName())
            .ToList();
    }
}


 manager =  NotificationManager();
manager.RegisterService( EmailNotificationService(, , , ));
manager.RegisterService( SmsNotificationService(, ));
manager.RegisterService( PushNotificationService(, ));

 manager.NotifyAsync(, , );

Method Overloading

Overloading in Java

public class Calculator {
    // Method overloading - same name, different parameters

    // Add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Add three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // Add two doubles
    public double add(double a, double b) {
        return a + b;
    }

    // Add array of integers
    public int add(int[] numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }

    // Add with different type combinations
    public double add(int a, double b) {
        return a + b;
    }

    public double add {
         a + b;
    }
}


   {
     String  {
         text.trim();
    }

     String  {
           format(text);
         uppercase ? trimmed.toUpperCase() : trimmed.toLowerCase();
    }

     String  {
           format(text);
         trimmed.length() > maxLength
            ? trimmed.substring(, maxLength) + 
            : trimmed;
    }

     String  {
           format(text, uppercase);
         format(formatted, maxLength);
    }
}

Overloading in C

public class DocumentProcessor
{
    // Process string content
    public ProcessResult Process(string content)
    {
        return new ProcessResult
        {
            Type = "text",
            Length = content.Length,
            ProcessedContent = content.Trim()
        };
    }

    // Process byte array (binary content)
    public ProcessResult Process(byte[] content)
    {
        return new ProcessResult
        {
            Type = "binary",
            Length = content.Length,
            ProcessedContent = Convert.ToBase64String(content)
        };
    }

    // Process with options
    public ProcessResult Process(string content, ProcessOptions options)
    {
        var result = Process(content);

        if (options.RemoveWhitespace)
        {
            result.ProcessedContent = Regex.Replace(
                result.ProcessedContent.ToString(),
                @"\s+",
                " "
            );
        }

        if (options.MaxLength > 0)
        {
            var text = result.ProcessedContent.ToString();
            result.ProcessedContent = text.Length > options.MaxLength
                ? text.Substring(0, options.MaxLength)
                : text;
        }

        return result;
    }

    // Process file
    public async Task<ProcessResult> ()
    {
         content =  File.ReadAllTextAsync(.FullName);
         Process(content);
    }

    
    
    {
          reader =  StreamReader(stream);
         content =  reader.ReadToEndAsync();
         Process(content);
    }
}

Operator Overloading

C# Operator Overloading

public struct Vector3D
{
    public double X { get; }
    public double Y { get; }
    public double Z { get; }

    public Vector3D(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }

    // Binary operator overloading
    public static Vector3D operator +(Vector3D a, Vector3D b)
    {
        return new Vector3D(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
    }

    public static Vector3D operator -(Vector3D a, Vector3D b)
    {
        return new Vector3D(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
    }

    public static Vector3D operator *(Vector3D v, double scalar)
    {
        return new Vector3D(v.X * scalar, v.Y * scalar, v.Z * scalar);
    }

    public static Vector3D operator *(double scalar, Vector3D v)
    {
        return v * scalar;
    }

    public static Vector3D operator /(Vector3D v, double scalar)
    {
        if (scalar == 0)
            throw new DivideByZeroException();
          Vector3D(v.X / scalar, v.Y / scalar, v.Z / scalar);
    }

    
      Vector3D  -(Vector3D v)
    {
          Vector3D(-v.X, -v.Y, -v.Z);
    }

    
        ==(Vector3D a, Vector3D b)
    {
         a.X == b.X && a.Y == b.Y && a.Z == b.Z;
    }

        !=(Vector3D a, Vector3D b)
    {
         !(a == b);
    }

    
    
    {
         obj  Vector3D vector &&  == vector;
    }

    
    {
         HashCode.Combine(X, Y, Z);
    }

    
    {
         ;
    }

    
    
    {
         Math.Sqrt(X * X + Y * Y + Z * Z);
    }

    
    {
         mag = Magnitude();
         mag >  ?  / mag : ;
    }

    
    {
         X * other.X + Y * other.Y + Z * other.Z;
    }

    
    {
          Vector3D(
            Y * other.Z - Z * other.Y,
            Z * other.X - X * other.Z,
            X * other.Y - Y * other.X
        );
    }
}


 v1 =  Vector3D(, , );
 v2 =  Vector3D(, , );
 v3 = v1 + v2;  
 v4 = v1 * ;   
 v5 = -v1;      

Python Magic Methods (Operator Overloading)

class Money:
    """Money class with operator overloading."""

    def __init__(self, amount: float, currency: str = "USD"):
        self.amount = amount
        self.currency = currency

    def __add__(self, other):
        """Add two money amounts."""
        if isinstance(other, Money):
            if self.currency != other.currency:
                raise ValueError("Cannot add different currencies")
            return Money(self.amount + other.amount, self.currency)
        elif isinstance(other, (int, float)):
            return Money(self.amount + other, self.currency)
        return NotImplemented

    def __sub__(self, other):
        """Subtract two money amounts."""
        if isinstance(other, Money):
            if self.currency != other.currency:
                raise ValueError("Cannot subtract different currencies")
            return Money(self.amount - other.amount, .currency)
         (other, (, )):
             Money(.amount - other, .currency)
         

     ():
        
         (other, (, )):
             Money(.amount * other, .currency)
         

     ():
        
         (other, (, )):
             other == :
                 ValueError()
             Money(.amount / other, .currency)
         

     ():
        
          (other, Money):
             
         .amount == other.amount  .currency == other.currency

     ():
        
          (other, Money):
             
         .currency != other.currency:
             ValueError()
         .amount < other.amount

     ():
        
          == other   < other

     ():
        
          (other, Money):
             
         .currency != other.currency:
             ValueError()
         .amount > other.amount

     ():
        
          == other   > other

     ():
        
         

     ():
        
         

     ():
        
         ((.amount, .currency))


price = Money()
tax = Money()
total = price + tax  
discounted = total *   
(total > price)  

Duck Typing and Structural Polymorphism

Duck Typing in Python

# No explicit interface - objects just need the right methods
class FileWriter:
    """Writes to a file."""

    def __init__(self, filename: str):
        self.file = open(filename, 'w')

    def write(self, data: str) -> None:
        self.file.write(data)

    def close(self) -> None:
        self.file.close()

class StringWriter:
    """Writes to a string buffer."""

    def __init__(self):
        self.buffer = []

    def write(self, data: str) -> None:
        self.buffer.append(data)

    def close(self) -> None:
        pass  # Nothing to close

    def get_value(self) -> str:
        return ''.join(self.buffer)

class NetworkWriter:
    

     ():
        .host = host
        .port = port
        .connected = 

     () -> :
        ()

     () -> :
        .connected = 
        ()


 () -> :
    
    writer.write()
    writer.write( *  + )

     item  data:
        writer.write()

    writer.close()


save_report(FileWriter(), , [, ])
save_report(StringWriter(), , [, ])
save_report(NetworkWriter(, ), , [])

When to Use This Skill

Apply polymorphism when:

1. Building extensible plugin architectures
2. Creating interchangeable implementations
3. Writing code against interfaces/abstractions
4. Implementing the strategy pattern
5. Building dependency injection systems
6. Creating framework hooks and extension points
7. Supporting multiple data formats or protocols
8. Implementing command patterns
9. Building notification or messaging systems
10. Creating abstract data access layers
11. Supporting multiple rendering engines
12. Implementing visitor patterns
13. Building state machines with polymorphic states
14. Creating factory methods that return polymorphic types
15. Designing testable code with mock objects

Best Practices

1. Program to interfaces, not implementations
2. Use abstract base classes for shared behavior
3. Keep interfaces small and focused (ISP)
4. Use polymorphism to eliminate switch statements
5. Favor composition over inheritance for flexibility
6. Make polymorphic methods virtual/abstract appropriately
7. Use dependency injection for polymorphic dependencies
8. Document the contract/behavior expected from implementations
9. Provide default implementations where sensible
10. Use generics with polymorphism for type safety
11. Override equality methods when overriding operators
12. Keep polymorphic hierarchies shallow
13. Use factory patterns to create polymorphic objects
14. Test each implementation of a polymorphic interface
15. Consider using protocols/structural typing for flexibility

Common Pitfalls

1. Breaking Liskov Substitution Principle
2. Creating too many small interfaces
3. Not providing consistent behavior across implementations
4. Overusing inheritance for polymorphism
5. Forgetting to override Object methods (equals, hashCode)
6. Creating leaky abstractions
7. Mixing abstraction levels in interfaces
8. Not handling null/None in polymorphic code
9. Creating circular dependencies between polymorphic types
10. Overloading methods with similar but different semantics
11. Not considering performance of virtual method calls
12. Using reflection instead of polymorphism
13. Creating god interfaces with too many methods
14. Not testing substitutability of implementations
15. Coupling to concrete types instead of abstractions

Resources

• Design Patterns: Elements of Reusable Object-Oriented Software
• Liskov Substitution Principle: https://en.wikipedia.org/wiki/Liskov_substitution_principle
• Python Protocols: https://peps.python.org/pep-0544/
• C# Interfaces: https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/types/interfaces
• Java Polymorphism Tutorial: https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html
• TypeScript Interfaces: https://www.typescriptlang.org/docs/handbook/interfaces.html
• Effective Java by Joshua Bloch (Item 64: Refer to objects by their interfaces)