Understanding Ruby Classes: A Refresher on Attributes and Methods

Overview

Welcome! Today, we’re diving into Ruby classes, the foundation of Object-Oriented Programming (OOP) in Ruby. This lesson introduces the concept of classes as blueprints for objects. We’ll explore how to create classes and objects, understand the difference between them, and see how attributes and methods store and manipulate data within each object.

Ruby Classes Refresher

In Ruby, a class serves as a blueprint for creating objects. Each object, or instance of a class, has its own data (attributes) and can perform actions (methods). Imagine a video game character: each character has attributes like health or strength, and methods like attack or defend. Here’s a simple GameCharacter class to illustrate these ideas: Ruby class GameCharacter # Constructor method to initialize attributes def initialize(name, health, strength) @name = name # instance variable for name @health = health # instance variable for health @strength = strength # instance variable for strength end # Method to simulate an attack def attack(target) target.health -= @strength # Reduces target's health by strength end # Accessors to allow reading and modifying instance variables externally attr_accessor :name, :health, :strength end Here, GameCharacter defines a blueprint for characters. The attributes @name, @health, and @strength store data specific to each character, while the attack method defines behavior each character can perform.

Creating Classes and Objects

In Ruby, creating an object is as simple as defining a class and calling new on that class. Each object created this way is an instance of the class and has its own copy of the class’s attributes. Ruby character_1 = GameCharacter.new("Hero", 100, 20) character_2 = GameCharacter.new("Villain", 80, 15) puts character_1.name # Output: Hero puts character_2.health # Output: 80 Each instance, character_1 and character_2, has its own unique data, demonstrating how a class can produce multiple distinct objects.

Understanding Attributes in Ruby Classes

Attributes, represented by instance variables prefixed with @, hold data specific to each instance. In the GameCharacter class, @name, @health, and @strength are instance variables storing each character's state. In Ruby, instance variables are private by default, meaning they cannot be accessed directly from outside the class. Instead, we need getter and setter methods to retrieve and update these values.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Ruby

class Person
  def initialize(name)
    @name = name  # private instance variable
  end

  attr_reader :name  # allows reading @name outside the class
end

person = Person.new("Alice")
puts person.name  # Output: Alice
# person.name = "Bob"  # Error: undefined method `name='

Ruby

class Secret
  def initialize(secret_code)
    @secret_code = secret_code  # private instance variable
  end

  attr_writer :secret_code  # allows modifying @secret_code outside the class
end

secret = Secret.new("1234")
secret.secret_code = "5678"  # Update only, no reading method
# puts secret.secret_code  # Error: undefined method `secret_code'

Ruby

class Account
  def initialize(balance)
    @balance = balance  # private instance variable
  end

  attr_accessor :balance  # allows both reading and modifying @balance
end

account = Account.new(100)
puts account.balance  # Output: 100
account.balance = 200
puts account.balance  # Output: 200

Ruby

puts character_2.health  # Output: 80 (before being attacked)
puts character_1.strength  # Output: 20 (the strength of the attacker)
character_1.attack(character_2)  # Decrease the health of character 2 by the strength of attacker
puts character_2.health  # Output: 60 (after being attacked)

Ruby

class BankAccount
  # Initializes a new account with holder's name and an optional starting balance (default 0).
  def initialize(holder_name, balance = 0)
    @holder_name = holder_name  # Stores the account holder's name
    @balance = balance          # Stores the account balance
  end

  # Adds a positive amount to the balance.
  def deposit(amount)
    if amount > 0
      @balance += amount
      puts "#{amount} deposited. New balance: #{@balance}"
    else
      puts "Deposit amount must be positive."
    end
  end

  # Deducts a valid amount from the balance if sufficient funds are available.
  def withdraw(amount)
    if amount > 0 && amount <= @balance
      @balance -= amount
      puts "#{amount} withdrawn. Remaining balance: #{@balance}"
    else
      puts "Insufficient balance or invalid amount."
    end
  end

  # Getter and setter for holder_name and balance
  attr_accessor :holder_name, :balance
end

# Creates a new account and performs some transactions.
account = BankAccount.new("Alex", 1000)
account.deposit(500)  # Outputs "500 deposited. New balance: 1500"
account.withdraw(200)  # Outputs "200 withdrawn. Remaining balance: 1300"
puts "#{account.holder_name}'s balance: #{account.balance}"  # Outputs "Alex's balance: 1300"

Overview

Ruby Classes Refresher

Creating Classes and Objects

Understanding Attributes in Ruby Classes

Join the 1M+ learners on CodeSignal

Using attr_reader and attr_writer

Using attr_accessor

Defining Methods to Add Behavior

Example: A Simple BankAccount Class

Lesson Summary and Practice