The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Classes and Objects

Next ►
►

In Ruby, everything is an object. This includes numbers, strings, arrays, and even classes themselves. Understanding classes and objects is fundamental to mastering Ruby, as it is an object-oriented programming (OOP) language. This section will cover the basics of defining classes, creating objects, and understanding the relationship between classes and objects.

Key Concepts

  1. Class Definition: A blueprint for creating objects.
  2. Object: An instance of a class.
  3. Instance Variables: Variables that belong to an instance of a class.
  4. Instance Methods: Methods that can be called on an instance of a class.
  5. Initialize Method: A special method called when an object is instantiated.

Class Definition

A class in Ruby is defined using the class keyword followed by the class name. By convention, class names are written in CamelCase.

class Person
  # Class body goes here
end

Creating Objects

Objects are created by calling the new method on a class. This method returns an instance of the class.

person = Person.new

Instance Variables

Instance variables are variables that belong to an instance of a class. They are prefixed with an @ symbol.

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

In the example above, @name and @age are instance variables.

Instance Methods

Instance methods are methods that can be called on an instance of a class. They are defined using the def keyword.

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

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

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

Initialize Method

The initialize method is a special method in Ruby that is called when an object is instantiated. It is often used to set initial values for instance variables.

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

person = Person.new("Alice", 30)

In the example above, the initialize method sets the @name and @age instance variables when a new Person object is created.

Practical Example

Let's create a more comprehensive example to solidify these concepts.

class Car
  def initialize(make, model, year)
    @make = make
    @model = model
    @year = year
  end

  def details
    "This car is a #{@year} #{@make} #{@model}."
  end

  def start_engine
    "The #{@make} #{@model}'s engine is now running."
  end
end

my_car = Car.new("Toyota", "Corolla", 2020)
puts my_car.details       # Output: This car is a 2020 Toyota Corolla.
puts my_car.start_engine  # Output: The Toyota Corolla's engine is now running.

Exercises

Exercise 1: Define a Class

Define a class Book with the following attributes: title, author, and pages. Include an instance method description that returns a string describing the book.

class Book
  def initialize(title, author, pages)
    @title = title
    @author = author
    @pages = pages
  end

  def description
    "#{@title} by #{author}, #{@pages} pages."
  end
end

# Test your class
book = Book.new("1984", "George Orwell", 328)
puts book.description  # Output: 1984 by George Orwell, 328 pages.

Exercise 2: Create Objects

Create two objects of the Book class and print their descriptions.

book1 = Book.new("To Kill a Mockingbird", "Harper Lee", 281)
book2 = Book.new("The Great Gatsby", "F. Scott Fitzgerald", 180)

puts book1.description  # Output: To Kill a Mockingbird by Harper Lee, 281 pages.
puts book2.description  # Output: The Great Gatsby by F. Scott Fitzgerald, 180 pages.

Common Mistakes and Tips

  • Forgetting the @ symbol: Remember to use the @ symbol when defining instance variables.
  • Not using the initialize method: Always use the initialize method to set up initial values for instance variables.
  • Case sensitivity: Class names should be in CamelCase, and method/variable names should be in snake_case.

Conclusion

In this section, we covered the basics of classes and objects in Ruby. You learned how to define a class, create objects, and use instance variables and methods. These concepts are fundamental to understanding object-oriented programming in Ruby. In the next section, we will delve deeper into instance variables and methods, exploring more advanced features and best practices.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved