Code Examples: From Inheritance to Composition

In this section, we’ll explore detailed examples to demonstrate the practical benefits of refactoring from inheritance to composition. These examples highlight the flexibility and modularity that composition brings to your code.

Example 2: Employee Bonus System

Many systems calculate bonuses differently based on roles. Let’s see how we can refactor such a system to leverage composition effectively.

Inheritance-Based Implementation

class Employee
  def initialize(name)
    @name = name
  end

  def bonus
    1000
  end
end

class Manager < Employee
  def bonus
    super + 2000
  end
end

class Developer < Employee
  def bonus
    super + 1500
  end
end
        

While this implementation works, it tightly couples bonus logic to employee roles and creates duplication in subclasses. Adding new roles requires additional subclasses and modifications to existing code.

Refactored to Composition

class Bonus
  def initialize(base_bonus:, additional_bonus:)
    @base_bonus = base_bonus
    @additional_bonus = additional_bonus
  end

  def calculate
    @base_bonus + @additional_bonus
  end
end

manager_bonus = Bonus.new(base_bonus: 1000, additional_bonus: 2000)
developer_bonus = Bonus.new(base_bonus: 1000, additional_bonus: 1500)

puts manager_bonus.calculate # Outputs 3000
puts developer_bonus.calculate # Outputs 2500
        

This approach encapsulates bonus logic into a reusable `Bonus` class. Employee roles no longer need to define their own bonus logic, making the system more flexible and scalable.

Continue to Advanced Code Examples →