oop-inheritance-composition

name	oop-inheritance-composition
user-invocable	false
description	Use when deciding between inheritance and composition in object-oriented design. Use when creating class hierarchies or composing objects from smaller components.
allowed-tools	["Bash","Read"]

OOP Inheritance and Composition

Master inheritance and composition to build flexible, maintainable object-oriented systems. This skill focuses on understanding when to use inheritance versus composition and how to apply each effectively.

Inheritance Fundamentals

Basic Inheritance in Java

// Base class with common behavior
public abstract class Vehicle {
    private String brand;
    private String model;
    private int year;
    protected double currentSpeed;

    protected Vehicle(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.currentSpeed = 0.0;
    }

    // Template method pattern
    public final void start() {
        performSafetyCheck();
        startEngine();
        System.out.println(brand + " " + model + " started");
    }

    // Hook method for subclasses
    protected void performSafetyCheck() {
        System.out.println("Performing basic safety check");
    }

    // Abstract method - must be implemented
    protected abstract void startEngine();

    public void accelerate(double speed) {
        currentSpeed += speed;
        System.out.println("Current speed: " + currentSpeed);
    }

    public void brake(double reduction) {
        currentSpeed = Math.max(0, currentSpeed - reduction);
        System.out.println("Current speed: " + currentSpeed);
    }

    // Getters
    public String getBrand() { return brand; }
    public String getModel() { return model; }
    public int getYear() { return year; }
    public double getCurrentSpeed() { return currentSpeed; }
}

// Concrete implementation
public class Car extends Vehicle {
    private int numberOfDoors;
    private boolean isSunroofOpen;

    public Car(String brand, String model, int year, int numberOfDoors) {
        super(brand, model, year);
        this.numberOfDoors = numberOfDoors;
        this.isSunroofOpen = false;
    }

    @Override
    protected void startEngine() {
        System.out.println("Car engine started with ignition");
    }

    @Override
    protected void performSafetyCheck() {
        super.performSafetyCheck();
        System.out.println("Checking doors are closed");
        System.out.println("Checking seatbelts");
    }

    public void openSunroof() {
        if (currentSpeed == 0) {
            isSunroofOpen = true;
            System.out.println("Sunroof opened");
        } else {
            System.out.println("Stop the car before opening sunroof");
        }
    }

    public int getNumberOfDoors() {
        return numberOfDoors;
    }
}

// Another concrete implementation
public class Motorcycle extends Vehicle {
    private boolean hasWindshield;

    public Motorcycle(String brand, String model, int year, boolean hasWindshield) {
        super(brand, model, year);
        this.hasWindshield = hasWindshield;
    }

    @Override
    protected void startEngine() {
        System.out.println("Motorcycle engine started with kick/button");
    }

    @Override
    public void accelerate(double speed) {
        // Override to add motorcycle-specific behavior
        if (currentSpeed + speed > 200) {
            System.out.println("Warning: Maximum safe speed exceeded!");
        }
        super.accelerate(speed);
    }

    public boolean hasWindshield() {
        return hasWindshield;
    }
}

Inheritance in Python

from abc import ABC, abstractmethod
from typing import List, Optional
from datetime import datetime

class Employee(ABC):
    """Abstract base class for all employees."""

    def __init__(self, employee_id: str, name: str, email: str, hire_date: datetime):
        self._employee_id = employee_id
        self._name = name
        self._email = email
        self._hire_date = hire_date
        self._is_active = True

    @property
    def employee_id(self) -> str:
        return self._employee_id

    @property
    def name(self) -> str:
        return self._name

    @property
    def email(self) -> str:
        return self._email

    @property
    def hire_date(self) -> datetime:
         ._hire_date


     () -> :
         (datetime.now() - ._hire_date).days // 

    
     () -> :
        
          ._is_active:
             ValueError()

        base_pay = .calculate_pay()
        bonus = .calculate_bonus()
        deductions = .calculate_deductions()

        total_pay = base_pay + bonus - deductions
        .record_payment(total_pay)
         total_pay

    

     () -> :
        
        

    
     () -> :
        
         

     () -> :
        
         

     () -> :
        
        ()

     () -> :
        
        ._is_active = 


 ():
    

     ():
        ().__init__(employee_id, name, email, hire_date)
        ._annual_salary = annual_salary

     () -> :
        
         ._annual_salary / 

     () -> :
        
         ._annual_salary *  * .years_of_service


 ():
    

     ():
        ().__init__(employee_id, name, email, hire_date)
        ._hourly_rate = hourly_rate
        ._hours_worked = 

     () -> :
        
         hours < :
             ValueError()
        ._hours_worked += hours

     () -> :
        
        regular_hours = (._hours_worked, )
        overtime_hours = (, ._hours_worked - )

        regular_pay = regular_hours * ._hourly_rate
        overtime_pay = overtime_hours * ._hourly_rate * 

         regular_pay + overtime_pay

     () -> :
        
        ().record_payment(amount)
        ._hours_worked = 


 ():
    

     ():
        ().__init__(employee_id, name, email, hire_date, annual_salary)
        ._commission_rate = commission_rate
        ._sales_this_period = 

     () -> :
        
         amount <= :
             ValueError()
        ._sales_this_period += amount

     () -> :
        
        base = ().calculate_pay()
        commission = ._sales_this_period * ._commission_rate
         base + commission

     () -> :
        
        ().record_payment(amount)
        ._sales_this_period = 

Inheritance in TypeScript

// Abstract base class
abstract class Shape {
  protected readonly id: string;
  protected color: string;

  constructor(color: string) {
    this.id = crypto.randomUUID();
    this.color = color;
  }

  // Abstract methods
  abstract area(): number;
  abstract perimeter(): number;
  abstract draw(): void;

  // Concrete methods
  getColor(): string {
    return this.color;
  }

  setColor(color: string): void {
    this.color = color;
  }

  describe(): string {
    return `${this.constructor.name} (${this.color}): Area = ${this.area().toFixed()}, Perimeter = `;
  }
}


    {
   : ;

  () {
    (color);
     (radius <= ) {
        ();
    }
    . = radius;
  }

  ():  {
     . * . ** ;
  }

  ():  {
      * . * .;
  }

  ():  {
    .();
  }

  ():  {
     .;
  }
}

    {
   : ;
   : ;

  () {
    (color);
     (width <=  || height <= ) {
        ();
    }
    . = width;
    . = height;
  }

  ():  {
     . * .;
  }

  ():  {
      * (. + .);
  }

  ():  {
    .();
  }

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

    {
   : ;
   : ;
   : ;

  () {
    (color);
     (!.(sideA, sideB, sideC)) {
        ();
    }
    . = sideA;
    . = sideB;
    . = sideC;
  }

   (: , : , : ):  {
     a + b > c && b + c > a && a + c > b;
  }

  ():  {
    
     s = .() / ;
     .(s * (s - .) * (s - .) * (s - .));
  }

  ():  {
     . + . + .;
  }

  ():  {
    .();
  }
}

Composition Over Inheritance

Composition in Java

// Component interfaces
interface Engine {
    void start();
    void stop();
    int getHorsepower();
}

interface Transmission {
    void shiftUp();
    void shiftDown();
    String getType();
}

interface GPS {
    void navigate(String destination);
    String getCurrentLocation();
}

// Concrete component implementations
class V6Engine implements Engine {
    private final int horsepower;
    private boolean running;

    public V6Engine(int horsepower) {
        this.horsepower = horsepower;
        this.running = false;
    }

    @Override
    public void start() {
        running = true;
        System.out.println();
    }

    
       {
        running = ;
        System.out.println();
    }

    
       {
         horsepower;
    }
}

    {
       horsepower;
      running;
      batteryLevel;

      {
        .horsepower = horsepower;
        .batteryLevel = ;
        .running = ;
    }

    
       {
         (batteryLevel > ) {
            running = ;
            System.out.println();
        }  {
            System.out.println();
        }
    }

    
       {
        running = ;
        System.out.println();
    }

    
       {
         horsepower;
    }

       {
         batteryLevel;
    }
}

    {
      currentGear;

      {
        .currentGear = ;
    }

    
       {
         (currentGear < ) {
            currentGear++;
            System.out.println( + currentGear);
        }
    }

    
       {
         (currentGear > ) {
            currentGear--;
            System.out.println( + currentGear);
        }
    }

    
     String  {
         ;
    }
}

    {
      currentGear;

      {
        .currentGear = ;
    }

    
       {
         (currentGear < ) {
            currentGear++;
            System.out.println( + currentGear);
        }
    }

    
       {
         (currentGear > ) {
            currentGear--;
            System.out.println( + currentGear);
        }
    }

    
     String  {
         ;
    }
}


   {
      Engine engine;
      Transmission transmission;
      GPS gps;  
      String brand;
      String model;

    
        {
         Engine engine;
         Transmission transmission;
         GPS gps;
         String brand;
         String model;

         Builder  {
            .brand = brand;
             ;
        }

         Builder  {
            .model = model;
             ;
        }

         Builder  {
            .engine = engine;
             ;
        }

         Builder  {
            .transmission = transmission;
             ;
        }

         Builder  {
            .gps = gps;
             ;
        }

         ComposedCar  {
             (engine ==  || transmission == ) {
                  ();
            }
              ();
        }
    }

      {
        .engine = builder.engine;
        .transmission = builder.transmission;
        .gps = builder.gps;
        .brand = builder.brand;
        .model = builder.model;
    }

    
       {
        engine.start();
        System.out.println(brand +  + model + );
    }

       {
        engine.stop();
    }

       {
        transmission.shiftUp();
    }

       {
        transmission.shiftDown();
    }

       {
         (gps != ) {
            gps.navigate(destination);
        }  {
            System.out.println();
        }
    }

     String  {
         String.format(,
            brand, model, engine.getHorsepower(), transmission.getType());
    }
}


    .Builder()
    .brand()
    .model()
    .engine( ())
    .transmission( ())
    .build();

    .Builder()
    .brand()
    .model()
    .engine( ())
    .transmission( ())
    .build();

Composition in Python

from typing import Protocol, List, Optional
from dataclasses import dataclass

# Component protocols (interfaces)
class Renderer(Protocol):
    """Protocol for rendering components."""
    def render(self, content: str) -> str: ...

class Logger(Protocol):
    """Protocol for logging components."""
    def log(self, message: str, level: str) -> None: ...

class Validator(Protocol):
    """Protocol for validation components."""
    def validate(self, data: dict) -> bool: ...
    def get_errors(self) -> List[str]: ...

# Concrete component implementations
class HTMLRenderer:
    """Renders content as HTML."""

    def render(self, content: str) -> str:
        return 

 :
    

     () -> :
         

 :
    

     ():
        .filename = filename

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

 :
    

     () -> :
        ()

 :
    

     ():
        .errors: [] = []

     () -> :
        .errors = []
        email = data.get(, )

          email:
            .errors.append()
             

            email:
            .errors.append()
             

            email.split()[]:
            .errors.append()
             

         

     () -> []:
         .errors


 :
    

     ():
        ._renderer = renderer
        ._logger = logger
        ._validator = validator

     () -> []:
        
        ._logger.log(, )

        
          ._validator.validate(user_data):
            errors = ._validator.get_errors()
            ._logger.log(, )
             

        
        user_content = 

        
        rendered = ._renderer.render(user_content)
        ._logger.log(, )

         rendered


 :
    

     ():
        ._loggers = loggers

     () -> :
         logger  ._loggers:
            logger.log(message, level)

     () -> :
        ._loggers.append(logger)


html_service = UserService(
    renderer=HTMLRenderer(),
    logger=ConsoleLogger(),
    validator=EmailValidator()
)

markdown_service = UserService(
    renderer=MarkdownRenderer(),
    logger=CompositeLogger([ConsoleLogger(), FileLogger()]),
    validator=EmailValidator()
)

Strategy Pattern with Composition in C

// Strategy interfaces
public interface IPaymentStrategy
{
    PaymentResult ProcessPayment(decimal amount);
    bool IsAvailable();
}

public interface IShippingStrategy
{
    decimal CalculateCost(decimal weight, string destination);
    int EstimateDeliveryDays();
}

public interface IDiscountStrategy
{
    decimal ApplyDiscount(decimal originalPrice);
}

// Concrete strategies
public class CreditCardPayment : IPaymentStrategy
{
    private readonly string _cardNumber;
    private readonly string _cvv;

    public CreditCardPayment(string cardNumber, string cvv)
    {
        _cardNumber = cardNumber;
        _cvv = cvv;
    }

    public PaymentResult ProcessPayment(decimal amount)
    {
        
        Console.WriteLine();
         PaymentResult.Success(Guid.NewGuid().ToString());
    }

     => ;
}

   : 
{
       _email;

    
    {
        _email = email;
    }

    
    {
        Console.WriteLine();
         PaymentResult.Success(Guid.NewGuid().ToString());
    }

     => ;
}

   : 
{
    
    {
         weight * m;
    }

     => ;
}

   : 
{
    
    {
         weight * m;
    }

     => ;
}

   : 
{
       _percentage;

    
    {
        _percentage = percentage;
    }

    
    {
         originalPrice * ( - _percentage / );
    }
}

   : 
{
       _amount;

    
    {
        _amount = amount;
    }

    
    {
         Math.Max(, originalPrice - _amount);
    }
}


  
{
     IPaymentStrategy _paymentStrategy;
     IShippingStrategy _shippingStrategy;
     IDiscountStrategy? _discountStrategy;

    
    {
        _paymentStrategy = paymentStrategy ??   ArgumentNullException((paymentStrategy));
        _shippingStrategy = shippingStrategy ??   ArgumentNullException((shippingStrategy));
        _discountStrategy = discountStrategy;
    }

    
    
    {
        _paymentStrategy = strategy ??   ArgumentNullException((strategy));
    }

    
    {
        _shippingStrategy = strategy ??   ArgumentNullException((strategy));
    }

    
    {
        _discountStrategy = strategy;
    }

    
    {
        
         subtotal = order.Items.Sum(item => item.Price * item.Quantity);

        
         total = _discountStrategy?.ApplyDiscount(subtotal) ?? subtotal;

        
         shippingCost = _shippingStrategy.CalculateCost(order.TotalWeight, order.Destination);
        total += shippingCost;

        
         (!_paymentStrategy.IsAvailable())
        {
             OrderResult.Failed();
        }

         paymentResult = _paymentStrategy.ProcessPayment(total);
         (!paymentResult.IsSuccess)
        {
             OrderResult.Failed();
        }

         OrderResult.Success(
            order.Id,
            total,
            _shippingStrategy.EstimateDeliveryDays()
        );
    }
}


 processor =  OrderProcessor(
     CreditCardPayment(, ),
     StandardShipping(),
     PercentageDiscount()
);


processor.SetShippingStrategy( ExpressShipping());
processor.SetDiscountStrategy( FixedAmountDiscount());

Mixin Pattern

Mixins in Python

from typing import Any
import json

# Mixin classes providing specific functionality
class JsonSerializableMixin:
    """Mixin to add JSON serialization."""

    def to_json(self) -> str:
        """Serialize object to JSON."""
        return json.dumps(self.__dict__)

    @classmethod
    def from_json(cls, json_str: str) -> Any:
        """Deserialize from JSON."""
        data = json.loads(json_str)
        return cls(**data)

class TimestampMixin:
    """Mixin to add timestamp tracking."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.created_at = datetime.now()
        self.updated_at = datetime.now()

    def touch(self) -> None:
        """Update the updated_at timestamp."""
        self.updated_at = datetime.now()

class ValidationMixin:
    """Mixin to add validation capabilities."""

    def validate(self) -> bool:
        """Validate object state."""
        errors = .get_validation_errors()
         (errors) == 

     () -> []:
        
        errors = []
         attr_name, attr_value  .__dict__.items():
             attr_value     attr_name.startswith():
                errors.append()
         errors

 :
    

     ():
        ().__init__(*args, **kwargs)
        ._changes: [] = []

     () -> :
        
        ._changes.append({
            : field,
            : old_value,
            : new_value,
            : datetime.now()
        })

     () -> []:
        
         ._changes.copy()


 (TimestampMixin, JsonSerializableMixin, ValidationMixin, AuditMixin):
    

     ():
        ().__init__()
        ._username = username
        ._email = email
        ._age = age


     () -> :
         ._username


     () -> :
        old_value = ._username
        ._username = value
        .touch()
        .record_change(, old_value, value)


     () -> :
         ._email


     () -> :
        old_value = ._email
        ._email = value
        .touch()
        .record_change(, old_value, value)

     () -> []:
        
        errors = ().get_validation_errors()

         (._username) < :
            errors.append()

            ._email:
            errors.append()

         ._age < :
            errors.append()

         errors


user = User(, , )
user.username = 
(user.to_json())
(user.get_audit_trail())
(user.validate())

Interface Segregation

Multiple Interfaces in Java

// Segregated interfaces - clients only depend on what they need
interface Readable {
    String read();
}

interface Writable {
    void write(String content);
}

interface Appendable {
    void append(String content);
}

interface Searchable {
    List<String> search(String query);
}

// Read-only document
class ReadOnlyDocument implements Readable {
    private final String content;

    public ReadOnlyDocument(String content) {
        this.content = content;
    }

    @Override
    public String read() {
        return content;
    }
}

// Full-featured document
class Document implements Readable, Writable, Appendable, Searchable {
    private StringBuilder content;

    public Document(String initialContent) {
        this.content = new StringBuilder(initialContent);
    }

    @Override
     String  {
         content.toString();
    }

    
       {
        content =  (newContent);
    }

    
       {
        content.append(additionalContent);
    }

    
     List<String>  {
        List<String> results =  <>();
        String[] lines = content.toString().split();
         (String line : lines) {
             (line.contains(query)) {
                results.add(line);
            }
        }
         results;
    }
}


  {
      Readable document;

      {
        .document = document;
    }

       {
        System.out.println(document.read());
    }
}


  {
      Readable readable;
      Searchable searchable;

      {
        .readable = readable;
        .searchable = searchable;
    }

       {
        List<String> results = searchable.search(query);
        results.forEach(System.out::println);
    }
}

When to Use This Skill

Apply inheritance and composition when:

1. Designing class hierarchies with shared behavior
2. Modeling IS-A relationships (inheritance)
3. Modeling HAS-A relationships (composition)
4. Creating extensible frameworks
5. Implementing template methods
6. Building flexible, configurable systems
7. Avoiding code duplication across related classes
8. Supporting runtime behavior changes (composition)
9. Implementing the strategy pattern
10. Creating plugin architectures
11. Building testable code with dependency injection
12. Avoiding deep inheritance hierarchies
13. Supporting multiple implementations of behavior
14. Creating reusable components
15. Implementing interface segregation

Best Practices

1. Favor composition over inheritance for flexibility
2. Use inheritance for true IS-A relationships
3. Keep inheritance hierarchies shallow (2-3 levels max)
4. Make base classes abstract when appropriate
5. Use interfaces/protocols for behavior contracts
6. Prefer small, focused interfaces over large ones
7. Use dependency injection for composable designs
8. Document the template method pattern clearly
9. Override methods properly with super calls when needed
10. Use final/sealed to prevent further inheritance
11. Compose behavior from small, single-purpose components
12. Use the strategy pattern for runtime behavior changes
13. Avoid protected fields, use protected methods instead
14. Make composed objects immutable when possible
15. Test each component independently

Common Pitfalls

1. Creating deep inheritance hierarchies
2. Using inheritance for code reuse alone
3. Inheriting from concrete classes
4. Breaking Liskov Substitution Principle
5. Creating God classes with too many responsibilities
6. Overusing inheritance when composition would work better
7. Making everything inherit from a common base class
8. Using protected fields instead of private
9. Forgetting to call super() in constructors
10. Creating circular dependencies in composition
11. Not considering the fragile base class problem
12. Using implementation inheritance over interface inheritance
13. Creating tight coupling through inheritance
14. Not properly overriding equals/hashCode in subclasses
15. Mixing concerns in base classes

Resources

• Design Patterns: Elements of Reusable Object-Oriented Software
• Effective Java by Joshua Bloch (Favor composition over inheritance)
• Head First Design Patterns
• Python Multiple Inheritance: https://docs.python.org/3/tutorial/classes.html#multiple-inheritance
• C# Inheritance: https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/inheritance
• Java Inheritance Tutorial: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
• TypeScript Classes: https://www.typescriptlang.org/docs/handbook/2/classes.html