Ruby - Abstraction Example

1. Introduction

Abstraction is a vital concept in object-oriented programming that allows developers to hide complex implementation details and present only the necessary features of an object. By doing so, it simplifies the interaction and enhances the readability of the code. In this blog post, we'll explore the concept of abstraction in Ruby and see how it helps in creating a clean and organized codebase.

Definition

Abstraction is the process of hiding the intricate details and displaying only the essential features of an object. This doesn't mean that the hidden details are not important; they are encapsulated and kept from the user to avoid complexity. By presenting only the required functionalities, abstraction ensures that the system remains user-friendly and adaptable to changes.

2. Program Steps

1. Define a base class with some private methods (hidden details) and public methods (exposed essential features).

2. Instantiate the class.

3. Call the public methods on the object.

3. Code Program

# Define a basic Car class
class Car
  # Public method to start the car
  def start
    # Calling private methods within a public method
    ignite_engine
    "Car started!"
  end
  # Public method to stop the car
  def stop
    # Calling private methods within a public method
    shut_engine
    "Car stopped!"
  end
  private
  # Private method representing the details of igniting the engine
  def ignite_engine
    # Logic to ignite the engine
  end
  # Private method representing the details of shutting the engine
  def shut_engine
    # Logic to shut off the engine
  end
end
# Create an object of the Car class
my_car = Car.new
# Use the object's public methods
puts my_car.start
puts my_car.stop

Output:

Car started!
Car stopped!

Explanation:

1. We've created a Car class that has public methods start and stop. These methods represent the essential features of a car.

2. Within the Car class, there are private methods ignite_engine and shut_engine. These methods encapsulate the internal workings or complex details of starting and stopping a car, respectively.

3. The public methods make use of the private methods to achieve their functionality. This encapsulation is an example of abstraction where the user (or the developer) does not need to know the internal mechanisms of how a car starts or stops.

4. We then create an object my_car of the Car class and call its public methods. The internal mechanisms, i.e., how the engine ignites or shuts down, remain hidden from the user, demonstrating the concept of abstraction.

By leveraging abstraction, we can simplify the representation of objects, making them more understandable and manageable.