Object-oriented programming (OOP) is a way of writing computer code that focuses on creating "objects." These objects are like digital versions of things we see in the real world. Just as real objects have characteristics and can do things, OOP objects have data and functions built into them.

Let's break OOP down into key concepts:

Objects

  • Think of objects as containers that hold both data and functions.
  • Example: A "Car" object might contain data (color, model) and functions (start engine, brake).

Classes

  • Classes are like blueprints for creating objects.
  • They define what data and functions an object will have.
  • Example: A "Car" class defines what all car objects will look like.

Inheritance

  • Allows new classes to be based on existing ones.
  • The new class inherits properties and methods from the parent class.
  • Example: An "ElectricCar" class could inherit from the "Car" class.

Encapsulation

  • Keeps the inner workings of an object hidden from the outside world.
  • Only exposes what's necessary through public methods.
  • Example: You can start a car, but you don't need to know exactly how the engine works.

Polymorphism

  • Allows objects of different classes to be treated as objects of a common parent class.
  • Example: Different types of vehicles (cars, bikes, boats) can all have a "move" method, but each implements it differently.

Abstraction

  • Simplifies complex systems by breaking them down into more manageable parts.
  • Hides unnecessary details and exposes only the essential features of an object.
  • Example: When driving a car, you just need to know how to use the steering wheel, pedals, and gears. You don't need to understand all the complex mechanics happening under the hood.

Abstraction allows programmers to create simplified models of real-world objects or processes, making code easier to understand and maintain. It's often considered one of the fundamental principles of OOP alongside encapsulation, inheritance, and polymorphism.

OOP helps organize code, makes it easier to reuse, and can make complex programs simpler to understand and maintain.

Example

# Abstraction and Encapsulation
class Vehicle
  def initialize(brand)
    @brand = brand  # Encapsulated instance variable
  end

  def start_engine
    puts "Engine starting..."
  end

  # Abstract method
  def move
    raise NotImplementedError, "You must implement the move method"
  end
end

# Inheritance
class Car < Vehicle
  def initialize(brand, model)
    super(brand)
    @model = model
  end

  # Encapsulation: Getter method
  def info
    "#{@brand} #{@model}"
  end

  # Polymorphism: Implementing the abstract method
  def move
    puts "Car is driving on the road"
  end
end

# Another class for Polymorphism example
class Boat < Vehicle
  def move
    puts "Boat is sailing on the water"
  end
end

# Creating objects
my_car = Car.new("Toyota", "Corolla")
my_boat = Boat.new("Yamaha")

# Using objects
puts my_car.info  # Output: Toyota Corolla
my_car.start_engine  # Output: Engine starting...
my_car.move  # Output: Car is driving on the road
my_boat.move  # Output: Boat is sailing on the water

# Polymorphism
vehicles = [my_car, my_boat]
vehicles.each { |vehicle| vehicle.move }

This code demonstrates:

  • Objects: my_car and my_boat are objects.
  • Classes: Vehicle, Car, and Boat are classes.
  • Inheritance: Car and Boat inherit from Vehicle.
  • Encapsulation: Instance variables like @brand are private, accessed through methods.
  • Polymorphism: Both Car and Boat implement move differently.
  • Abstraction: Vehicle provides an abstract move method.

Relationships between objects

Association

  • Represents a relationship between two or more objects
  • Objects are linked but can exist independently
  • Example: A Teacher object might be associated with multiple Student objects

Aggregation

  • A special form of association
  • Represents a "has-a" relationship
  • The contained object can exist independently of the container
  • Example: A Department has Employees, but Employees can exist without the Department

Composition

  • A stronger form of aggregation
  • Represents a "part-of" relationship
  • The contained object cannot exist independently of the container
  • Example: A House is composed of Rooms; Rooms don't typically exist outside of a House

These concepts describe different ways objects can be related to each other in OOP, helping to model complex systems and relationships more accurately.