Applying OOP Design Patterns in Ruby

Hello! Today, we'll venture into the realm of design patterns. Specifically, we'll tackle exercises that apply a single design pattern to problem-solving. Mastering these patterns is a surefire way to extend your coding skills.

Our goal today is to fortify your understanding of when and how to apply specific Object-Oriented Programming (OOP) design patterns. These patterns include Encapsulation, Polymorphism, Composition, and Abstraction.

We'll dissect four real-life scenarios and determine which pattern is applicable and why.

Let's get underway!

The Encapsulation pattern proves beneficial for the development of a Database Management System (DBMS). Each DBMS table represents a class, the fields represent private data members, and the functions operating on this data serve as methods.

Encapsulation ensures that data members are accessed through methods that promote data integrity and prevent inadvertent anomalies. Here's a mini-code snippet to support this concept:

class Employees
  def initialize
    @employees = {} # private data member
  end

  def add_employee(eid, name) # method to operate on private data
    @employees[eid] = name
  end

  def update_employee(eid, new_name) # method to operate on private data
    @employees[eid] = new_name if @employees.key?(eid)
  end

  def employee_details(eid)
    @employees[eid]
  end
end

employees = Employees.new
employees.add_employee(1, "John")
employees.add_employee(2, "Mark")

employees.update_employee(2, "Jake")

print employees.employee_details(2) # Outputs: Jake

In this context, Encapsulation restricts direct access to employee data, presenting a protective layer via designated methods.

When transitioning to GUI development, consider the creation of controls like buttons or checkboxes. Despite belonging to different classes, each responds differently when clicked. This situation illustrates Polymorphism, which allows us to handle different objects uniformly via a common interface.

Check out this illustrative example:

class Button
  def click
    puts "Button Clicked!"
  end
end

class CheckBox
  def click
    puts "CheckBox Clicked!"
  end
end

# Array of controls
controls = [Button.new, CheckBox.new]

# Iterate and invoke click on each control
controls.each(&:click)
# Outputs: Button Clicked!
# Outputs: CheckBox Clicked!

Despite sharing the common click interface, different controls display unique responses. This characteristic demonstrates Polymorphism.