thebushidocollective 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:
return self._hire_date
@property
def years_of_service(self) -> int:
return (datetime.now() - self._hire_date).days // 365
# Template method
def process_payroll(self) -> float:
"""Process payroll - template method."""
if not self._is_active:
raise ValueError("Cannot process payroll for inactive employee")
base_pay = self.calculate_pay()
bonus = self.calculate_bonus()
deductions = self.calculate_deductions()
total_pay = base_pay + bonus - deductions
self.record_payment(total_pay)
return total_pay
# Abstract methods - must be implemented by subclasses
@abstractmethod
def calculate_pay(self) -> float:
"""Calculate base pay."""
pass
# Hook methods with default implementation
def calculate_bonus(self) -> float:
"""Calculate bonus - can be overridden."""
return 0.0
def calculate_deductions(self) -> float:
"""Calculate deductions - can be overridden."""
return 0.0
def record_payment(self, amount: float) -> None:
"""Record payment."""
print(f"Recording payment of ${amount:.2f} for {self._name}")
def deactivate(self) -> None:
"""Deactivate employee."""
self._is_active = False
class SalariedEmployee(Employee):
"""Employee paid a fixed salary."""
def __init__(
self,
employee_id: str,
name: str,
email: str,
hire_date: datetime,
annual_salary: float
):
super().__init__(employee_id, name, email, hire_date)
self._annual_salary = annual_salary
def calculate_pay(self) -> float:
"""Calculate monthly salary."""
return self._annual_salary / 12
def calculate_bonus(self) -> float:
"""Annual bonus based on years of service."""
return self._annual_salary * 0.01 * self.years_of_service
class HourlyEmployee(Employee):
"""Employee paid by the hour."""
def __init__(
self,
employee_id: str,
name: str,
email: str,
hire_date: datetime,
hourly_rate: float
):
super().__init__(employee_id, name, email, hire_date)
self._hourly_rate = hourly_rate
self._hours_worked = 0.0
def log_hours(self, hours: float) -> None:
"""Log hours worked this period."""
if hours < 0:
raise ValueError("Hours cannot be negative")
self._hours_worked += hours
def calculate_pay(self) -> float:
"""Calculate pay based on hours worked."""
regular_hours = min(self._hours_worked, 40)
overtime_hours = max(0, self._hours_worked - 40)
regular_pay = regular_hours * self._hourly_rate
overtime_pay = overtime_hours * self._hourly_rate * 1.5
return regular_pay + overtime_pay
def record_payment(self, amount: float) -> None:
"""Record payment and reset hours."""
super().record_payment(amount)
self._hours_worked = 0.0
class CommissionEmployee(SalariedEmployee):
"""Employee with base salary plus commission."""
def __init__(
self,
employee_id: str,
name: str,
email: str,
hire_date: datetime,
annual_salary: float,
commission_rate: float
):
super().__init__(employee_id, name, email, hire_date, annual_salary)
self._commission_rate = commission_rate
self._sales_this_period = 0.0
def record_sale(self, amount: float) -> None:
"""Record a sale for commission calculation."""
if amount <= 0:
raise ValueError("Sale amount must be positive")
self._sales_this_period += amount
def calculate_pay(self) -> float:
"""Calculate base salary plus commission."""
base = super().calculate_pay()
commission = self._sales_this_period * self._commission_rate
return base + commission
def record_payment(self, amount: float) -> None:
"""Record payment and reset sales."""
super().record_payment(amount)
self._sales_this_period = 0.0
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(2)}, Perimeter = ${this.perimeter().toFixed(2)}`;
}
}
// Concrete implementations
class Circle extends Shape {
private radius: number;
constructor(color: string, radius: number) {
super(color);
if (radius <= 0) {
throw new Error("Radius must be positive");
}
this.radius = radius;
}
area(): number {
return Math.PI * this.radius ** 2;
}
perimeter(): number {
return 2 * Math.PI * this.radius;
}
draw(): void {
console.log(`Drawing a ${this.color} circle with radius ${this.radius}`);
}
getRadius(): number {
return this.radius;
}
}
class Rectangle extends Shape {
private width: number;
private height: number;
constructor(color: string, width: number, height: number) {
super(color);
if (width <= 0 || height <= 0) {
throw new Error("Dimensions must be positive");
}
this.width = width;
this.height = height;
}
area(): number {
return this.width * this.height;
}
perimeter(): number {
return 2 * (this.width + this.height);
}
draw(): void {
console.log(`Drawing a ${this.color} rectangle ${this.width}x${this.height}`);
}
isSquare(): boolean {
return this.width === this.height;
}
}
class Triangle extends Shape {
private sideA: number;
private sideB: number;
private sideC: number;
constructor(color: string, sideA: number, sideB: number, sideC: number) {
super(color);
if (!this.isValidTriangle(sideA, sideB, sideC)) {
throw new Error("Invalid triangle dimensions");
}
this.sideA = sideA;
this.sideB = sideB;
this.sideC = sideC;
}
private isValidTriangle(a: number, b: number, c: number): boolean {
return a + b > c && b + c > a && a + c > b;
}
area(): number {
// Heron's formula
const s = this.perimeter() / 2;
return Math.sqrt(s * (s - this.sideA) * (s - this.sideB) * (s - this.sideC));
}
perimeter(): number {
return this.sideA + this.sideB + this.sideC;
}
draw(): void {
console.log(`Drawing a ${this.color} triangle`);
}
}
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("V6 engine started");
}
@Override
public void stop() {
running = false;
System.out.println("V6 engine stopped");
}
@Override
public int getHorsepower() {
return horsepower;
}
}
class ElectricEngine implements Engine {
private final int horsepower;
private boolean running;
private int batteryLevel;
public ElectricEngine(int horsepower) {
this.horsepower = horsepower;
this.batteryLevel = 100;
this.running = false;
}
@Override
public void start() {
if (batteryLevel > 0) {
running = true;
System.out.println("Electric engine started silently");
} else {
System.out.println("Battery depleted!");
}
}
@Override
public void stop() {
running = false;
System.out.println("Electric engine stopped");
}
@Override
public int getHorsepower() {
return horsepower;
}
public int getBatteryLevel() {
return batteryLevel;
}
}
class AutomaticTransmission implements Transmission {
private int currentGear;
public AutomaticTransmission() {
this.currentGear = 1;
}
@Override
public void shiftUp() {
if (currentGear < 8) {
currentGear++;
System.out.println("Automatically shifted to gear " + currentGear);
}
}
@Override
public void shiftDown() {
if (currentGear > 1) {
currentGear--;
System.out.println("Automatically shifted to gear " + currentGear);
}
}
@Override
public String getType() {
return "Automatic";
}
}
class ManualTransmission implements Transmission {
private int currentGear;
public ManualTransmission() {
this.currentGear = 1;
}
@Override
public void shiftUp() {
if (currentGear < 6) {
currentGear++;
System.out.println("Manually shifted to gear " + currentGear);
}
}
@Override
public void shiftDown() {
if (currentGear > 1) {
currentGear--;
System.out.println("Manually shifted to gear " + currentGear);
}
}
@Override
public String getType() {
return "Manual";
}
}
// Composed car class
public class ComposedCar {
private final Engine engine;
private final Transmission transmission;
private final GPS gps; // Optional component
private final String brand;
private final String model;
// Builder for flexible construction
public static class Builder {
private Engine engine;
private Transmission transmission;
private GPS gps;
private String brand;
private String model;
public Builder brand(String brand) {
this.brand = brand;
return this;
}
public Builder model(String model) {
this.model = model;
return this;
}
public Builder engine(Engine engine) {
this.engine = engine;
return this;
}
public Builder transmission(Transmission transmission) {
this.transmission = transmission;
return this;
}
public Builder gps(GPS gps) {
this.gps = gps;
return this;
}
public ComposedCar build() {
if (engine == null || transmission == null) {
throw new IllegalStateException("Engine and transmission required");
}
return new ComposedCar(this);
}
}
private ComposedCar(Builder builder) {
this.engine = builder.engine;
this.transmission = builder.transmission;
this.gps = builder.gps;
this.brand = builder.brand;
this.model = builder.model;
}
// Delegate to components
public void start() {
engine.start();
System.out.println(brand + " " + model + " is ready to drive");
}
public void stop() {
engine.stop();
}
public void shiftUp() {
transmission.shiftUp();
}
public void shiftDown() {
transmission.shiftDown();
}
public void navigateTo(String destination) {
if (gps != null) {
gps.navigate(destination);
} else {
System.out.println("GPS not available");
}
}
public String getSpecs() {
return String.format("%s %s - %d HP %s transmission",
brand, model, engine.getHorsepower(), transmission.getType());
}
}
// Usage
ComposedCar sportsCar = new ComposedCar.Builder()
.brand("Porsche")
.model("911")
.engine(new V6Engine(450))
.transmission(new ManualTransmission())
.build();
ComposedCar electricCar = new ComposedCar.Builder()
.brand("Tesla")
.model("Model 3")
.engine(new ElectricEngine(283))
.transmission(new AutomaticTransmission())
.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 f"<html><body>{content}</body></html>"
class MarkdownRenderer:
"""Renders content as Markdown."""
def render(self, content: str) -> str:
return f"# {content}\n\nRendered as Markdown"
class FileLogger:
"""Logs messages to a file."""
def __init__(self, filename: str):
self.filename = filename
def log(self, message: str, level: str) -> None:
with open(self.filename, 'a') as f:
f.write(f"[{level}] {message}\n")
class ConsoleLogger:
"""Logs messages to console."""
def log(self, message: str, level: str) -> None:
print(f"[{level}] {message}")
class EmailValidator:
"""Validates email addresses."""
def __init__(self):
self.errors: List[str] = []
def validate(self, data: dict) -> bool:
self.errors = []
email = data.get('email', '')
if not email:
self.errors.append("Email is required")
return False
if '@' not in email:
self.errors.append("Email must contain @")
return False
if '.' not in email.split('@')[1]:
self.errors.append("Email must have valid domain")
return False
return True
def get_errors(self) -> List[str]:
return self.errors
# Composed class using dependency injection
class UserService:
"""Service composed of various components."""
def __init__(
self,
renderer: Renderer,
logger: Logger,
validator: Validator
):
self._renderer = renderer
self._logger = logger
self._validator = validator
def create_user(self, user_data: dict) -> Optional[str]:
"""Create user using composed components."""
self._logger.log(f"Creating user: {user_data.get('email')}", "INFO")
# Use validator component
if not self._validator.validate(user_data):
errors = self._validator.get_errors()
self._logger.log(f"Validation failed: {errors}", "ERROR")
return None
# Process user creation
user_content = f"User created: {user_data['email']}"
# Use renderer component
rendered = self._renderer.render(user_content)
self._logger.log("User created successfully", "INFO")
return rendered
# Component swapping at runtime
class CompositeLogger:
"""Logger that delegates to multiple loggers."""
def __init__(self, loggers: List[Logger]):
self._loggers = loggers
def log(self, message: str, level: str) -> None:
for logger in self._loggers:
logger.log(message, level)
def add_logger(self, logger: Logger) -> None:
self._loggers.append(logger)
# Usage with different compositions
html_service = UserService(
renderer=HTMLRenderer(),
logger=ConsoleLogger(),
validator=EmailValidator()
)
markdown_service = UserService(
renderer=MarkdownRenderer(),
logger=CompositeLogger([ConsoleLogger(), FileLogger('app.log')]),
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)
{
// Credit card processing logic
Console.WriteLine($"Processing ${amount} via credit card");
return PaymentResult.Success(Guid.NewGuid().ToString());
}
public bool IsAvailable() => true;
}
public class PayPalPayment : IPaymentStrategy
{
private readonly string _email;
public PayPalPayment(string email)
{
_email = email;
}
public PaymentResult ProcessPayment(decimal amount)
{
Console.WriteLine($"Processing ${amount} via PayPal");
return PaymentResult.Success(Guid.NewGuid().ToString());
}
public bool IsAvailable() => true;
}
public class StandardShipping : IShippingStrategy
{
public decimal CalculateCost(decimal weight, string destination)
{
return weight * 2.5m;
}
public int EstimateDeliveryDays() => 7;
}
public class ExpressShipping : IShippingStrategy
{
public decimal CalculateCost(decimal weight, string destination)
{
return weight * 5.0m;
}
public int EstimateDeliveryDays() => 2;
}
public class PercentageDiscount : IDiscountStrategy
{
private readonly decimal _percentage;
public PercentageDiscount(decimal percentage)
{
_percentage = percentage;
}
public decimal ApplyDiscount(decimal originalPrice)
{
return originalPrice * (1 - _percentage / 100);
}
}
public class FixedAmountDiscount : IDiscountStrategy
{
private readonly decimal _amount;
public FixedAmountDiscount(decimal amount)
{
_amount = amount;
}
public decimal ApplyDiscount(decimal originalPrice)
{
return Math.Max(0, originalPrice - _amount);
}
}
// Composed order processor
public class OrderProcessor
{
private IPaymentStrategy _paymentStrategy;
private IShippingStrategy _shippingStrategy;
private IDiscountStrategy? _discountStrategy;
public OrderProcessor(
IPaymentStrategy paymentStrategy,
IShippingStrategy shippingStrategy,
IDiscountStrategy? discountStrategy = null)
{
_paymentStrategy = paymentStrategy ?? throw new ArgumentNullException(nameof(paymentStrategy));
_shippingStrategy = shippingStrategy ?? throw new ArgumentNullException(nameof(shippingStrategy));
_discountStrategy = discountStrategy;
}
// Strategy can be changed at runtime
public void SetPaymentStrategy(IPaymentStrategy strategy)
{
_paymentStrategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
}
public void SetShippingStrategy(IShippingStrategy strategy)
{
_shippingStrategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
}
public void SetDiscountStrategy(IDiscountStrategy? strategy)
{
_discountStrategy = strategy;
}
public OrderResult ProcessOrder(Order order)
{
// Calculate total
decimal subtotal = order.Items.Sum(item => item.Price * item.Quantity);
// Apply discount
decimal total = _discountStrategy?.ApplyDiscount(subtotal) ?? subtotal;
// Calculate shipping
decimal shippingCost = _shippingStrategy.CalculateCost(order.TotalWeight, order.Destination);
total += shippingCost;
// Process payment
if (!_paymentStrategy.IsAvailable())
{
return OrderResult.Failed("Payment method not available");
}
var paymentResult = _paymentStrategy.ProcessPayment(total);
if (!paymentResult.IsSuccess)
{
return OrderResult.Failed("Payment failed");
}
return OrderResult.Success(
order.Id,
total,
_shippingStrategy.EstimateDeliveryDays()
);
}
}
// Usage
var processor = new OrderProcessor(
new CreditCardPayment("1234-5678-9012-3456", "123"),
new StandardShipping(),
new PercentageDiscount(10)
);
// Change strategy at runtime
processor.SetShippingStrategy(new ExpressShipping());
processor.SetDiscountStrategy(new FixedAmountDiscount(20));
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 = self.get_validation_errors()
return len(errors) == 0
def get_validation_errors(self) -> List[str]:
"""Get list of validation errors."""
errors = []
for attr_name, attr_value in self.__dict__.items():
if attr_value is None and not attr_name.startswith('_'):
errors.append(f"{attr_name} is required")
return errors
class AuditMixin:
"""Mixin to add audit trail."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._changes: List[dict] = []
def record_change(self, field: str, old_value: Any, new_value: Any) -> None:
"""Record a change to the audit trail."""
self._changes.append({
'field': field,
'old_value': old_value,
'new_value': new_value,
'timestamp': datetime.now()
})
def get_audit_trail(self) -> List[dict]:
"""Get the audit trail."""
return self._changes.copy()
# Combining mixins with a base class
class User(TimestampMixin, JsonSerializableMixin, ValidationMixin, AuditMixin):
"""User class with multiple mixed-in behaviors."""
def __init__(self, username: str, email: str, age: int):
super().__init__()
self._username = username
self._email = email
self._age = age
@property
def username(self) -> str:
return self._username
@username.setter
def username(self, value: str) -> None:
old_value = self._username
self._username = value
self.touch()
self.record_change('username', old_value, value)
@property
def email(self) -> str:
return self._email
@email.setter
def email(self, value: str) -> None:
old_value = self._email
self._email = value
self.touch()
self.record_change('email', old_value, value)
def get_validation_errors(self) -> List[str]:
"""Override to add specific validation."""
errors = super().get_validation_errors()
if len(self._username) < 3:
errors.append("Username must be at least 3 characters")
if '@' not in self._email:
errors.append("Email must be valid")
if self._age < 18:
errors.append("User must be at least 18 years old")
return errors
# Usage
user = User("john_doe", "john@example.com", 25)
user.username = "jane_doe"
print(user.to_json())
print(user.get_audit_trail())
print(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
public String read() {
return content.toString();
}
@Override
public void write(String newContent) {
content = new StringBuilder(newContent);
}
@Override
public void append(String additionalContent) {
content.append(additionalContent);
}
@Override
public List<String> search(String query) {
List<String> results = new ArrayList<>();
String[] lines = content.toString().split("\n");
for (String line : lines) {
if (line.contains(query)) {
results.add(line);
}
}
return results;
}
}
// Client that only needs reading
class DocumentViewer {
private final Readable document;
public DocumentViewer(Readable document) {
this.document = document;
}
public void display() {
System.out.println(document.read());
}
}
// Client that needs reading and searching
class DocumentSearcher {
private final Readable readable;
private final Searchable searchable;
public DocumentSearcher(Readable readable, Searchable searchable) {
this.readable = readable;
this.searchable = searchable;
}
public void findAndDisplay(String query) {
List<String> results = searchable.search(query);
results.forEach(System.out::println);
}
}
When to Use This Skill
Apply inheritance and composition when:
- Designing class hierarchies with shared behavior
- Modeling IS-A relationships (inheritance)
- Modeling HAS-A relationships (composition)
- Creating extensible frameworks
- Implementing template methods
- Building flexible, configurable systems
- Avoiding code duplication across related classes
- Supporting runtime behavior changes (composition)
- Implementing the strategy pattern
- Creating plugin architectures
- Building testable code with dependency injection
- Avoiding deep inheritance hierarchies
- Supporting multiple implementations of behavior
- Creating reusable components
- Implementing interface segregation
Best Practices
- Favor composition over inheritance for flexibility
- Use inheritance for true IS-A relationships
- Keep inheritance hierarchies shallow (2-3 levels max)
- Make base classes abstract when appropriate
- Use interfaces/protocols for behavior contracts
- Prefer small, focused interfaces over large ones
- Use dependency injection for composable designs
- Document the template method pattern clearly
- Override methods properly with super calls when needed
- Use final/sealed to prevent further inheritance
- Compose behavior from small, single-purpose components
- Use the strategy pattern for runtime behavior changes
- Avoid protected fields, use protected methods instead
- Make composed objects immutable when possible
- Test each component independently
Common Pitfalls
- Creating deep inheritance hierarchies
- Using inheritance for code reuse alone
- Inheriting from concrete classes
- Breaking Liskov Substitution Principle
- Creating God classes with too many responsibilities
- Overusing inheritance when composition would work better
- Making everything inherit from a common base class
- Using protected fields instead of private
- Forgetting to call super() in constructors
- Creating circular dependencies in composition
- Not considering the fragile base class problem
- Using implementation inheritance over interface inheritance
- Creating tight coupling through inheritance
- Not properly overriding equals/hashCode in subclasses
- 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