Core OOP Principles: Classes, Objects, Inheritance, Encapsulation, and Polymorphism

Classes and Objects

• Classes: A class in Ruby is a blueprint for creating objects. It defines a set of attributes and behaviors that the objects created from the class will have. Think of a class as a template, like a blueprint for a house, that describes what a house should look like and what features it should have.

  class Car
    # Attributes
    attr_accessor :make, :model, :year
  
    # Constructor
    def initialize(make, model, year)
      @make = make
      @model = model
      @year = year
    end
  
    # Method
    def display_info
      "#{year} #{make} #{model}"
    end
  end
  

• Objects: An object is an instance of a class. It is created from a class and represents a specific example of that class with its own set of attribute values.

  my_car = Car.new("Toyota", "Corolla", 2021)
  puts my_car.display_info  # Output: "2021 Toyota Corolla"
  

Inheritance

Inheritance allows a class to inherit attributes and methods from another class. This promotes code reusability and establishes a natural hierarchy between classes.

• Base Class (Parent Class): The class from which other classes inherit.

  class Vehicle
    def start_engine
      "Engine started"
    end
  end
  

• Sub Class (Child Class): The class that inherits from another class.

  class Truck < Vehicle
    def load_cargo
      "Cargo loaded"
    end
  end
  
  my_truck = Truck.new
  puts my_truck.start_engine  # Output: "Engine started"
  puts my_truck.load_cargo    # Output: "Cargo loaded"
  

Encapsulation

Encapsulation involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit or class. It also restricts direct access to some of the object’s components, which is a means of preventing unintended interference and misuse.

• Access Control: Ruby provides three types of access control to protect attributes and methods: public, protected, and private.

  class Person
    def initialize(name)
      @name = name
    end
  
    def public_method
      "I'm a public method"
    end
  
    protected
  
    def protected_method
      "I'm a protected method"
    end
  
    private
  
    def private_method
      "I'm a private method"
    end
  end
  

  • Public Methods: Accessible from any part of the code.
  • Protected Methods: Accessible only within the same class or subclasses.
  • Private Methods: Accessible only within the defining class.

Polymorphism

Polymorphism allows different classes to be treated as instances of the same class through a common interface. This is achieved by overriding methods in subclasses or implementing methods with the same name but different functionalities.

• Method Overriding:

  class Animal
    def speak
      "Some generic sound"
    end
  end
  
  class Dog < Animal
    def speak
      "Woof!"
    end
  end
  
  class Cat < Animal
    def speak
      "Meow!"
    end
  end
  
  animals = [Dog.new, Cat.new]
  animals.each { |animal| puts animal.speak }
  

  Output:

  Woof!
  Meow!
  

Creating and Using Classes in Ruby

Defining a Class

Creating a class in Ruby is straightforward. Use the class keyword followed by the class name (typically in CamelCase) and end with the end keyword.

class Person
  attr_accessor :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def greet
    "Hello, my name is #{@name} and I am #{@age} years old."
  end
end

Instantiating an Object

To create an instance of a class, use the new method, which calls the initialize method:

person = Person.new("Alice", 30)
puts person.greet  # Output: "Hello, my name is Alice and I am 30 years old."

Class Methods

Class methods are methods that are called on the class itself, not on instances of the class. Define class methods using the self. prefix.

class MathUtility
  def self.add(a, b)
    a + b
  end
end

puts MathUtility.add(5, 3)  # Output: 8

Working with Modules and Mixins

Modules

Modules in Ruby are collections of methods and constants. They are used to group related functionalities and can be included in classes to share behavior across multiple classes.

• Defining a Module:

  module Greeter
    def greet
      "Hello!"
    end
  end
  

• Including a Module in a Class:

  class Person
    include Greeter
  end
  
  person = Person.new
  puts person.greet  # Output: "Hello!"
  

Mixins

Mixins are a way to include shared functionality into multiple classes without using inheritance. By using modules as mixins, you can add specific methods to classes.

• Example of a Mixin:

  module Flyable
    def fly
      "I am flying!"
    end
  end
  
  class Bird
    include Flyable
  end
  
  class Airplane
    include Flyable
  end
  
  bird = Bird.new
  airplane = Airplane.new
  
  puts bird.fly       # Output: "I am flying!"
  puts airplane.fly  # Output: "I am flying!"
  

Real-World Examples of OOP in Ruby Applications

Example 1: A Simple Banking System

A basic banking system that uses OOP principles:

class Account
  attr_accessor :balance

  def initialize(balance)
    @balance = balance
  end

  def deposit(amount)
    @balance += amount
    "Deposited #{amount}. New balance is #{@balance}."
  end

  def withdraw(amount)
    if amount <= @balance
      @balance -= amount
      "Withdrew #{amount}. New balance is #{@balance}."
    else
      "Insufficient funds!"
    end
  end
end

class SavingsAccount < Account
  def initialize(balance, interest_rate)
    super(balance)
    @interest_rate = interest_rate
  end

  def apply_interest
    interest = @balance * @interest_rate / 100
    @balance += interest
    "Applied interest. New balance is #{@balance}."
  end
end

account = SavingsAccount.new(1000, 5)
puts account.deposit(500)         # Output: "Deposited 500. New balance is 1500."
puts account.withdraw(200)        # Output: "Withdrew 200. New balance is 1300."
puts account.apply_interest      # Output: "Applied interest. New balance is 1365."

Example 2: An E-Commerce System

Implementing a basic e-commerce system with products and orders:

class Product
  attr_accessor :name, :price

  def initialize(name, price)
    @name = name
    @price = price
  end
end

class Order
  def initialize
    @items = []
  end

  def add_product(product, quantity)
    @items << { product: product, quantity: quantity }
  end

  def total_amount
    @items.reduce(0) do |sum, item|
      sum + (item[:product].price * item[:quantity])
    end
  end
end

# Usage
laptop = Product.new("Laptop", 1200)
phone = Product.new("Phone", 800)

order = Order.new
order.add_product(laptop, 1)
order.add_product(phone, 2)

puts "Total order amount: #{order.total_amount}"  # Output: "Total order amount: 2800"

Conclusion

Mastering Object-Oriented Programming in Ruby involves understanding core concepts like classes, objects, inheritance, encapsulation, and polymorphism. By leveraging these principles, you can create well-organized, reusable, and maintainable code. With Ruby's elegant syntax and powerful OOP features, you'll be well-equipped to build robust and scalable applications.

Embrace the power of Ruby and its object-oriented approach to enhance your programming skills and develop sophisticated software solutions. Happy coding!