Ruby is pure object-oriented — you define classes (blueprints) and create objects (instances). Classes use initialize as the constructor, @variables for instance state, and access modifiers for encapsulation. Ruby's class syntax is clean and expressive.
class Person
def initialize(name, age) # the CONSTRUCTOR (called on .new)
@name = name # @ → instance variable (per object)
@age = age
end
def greet # an instance method
"Hi, I'm #{@name}"
end
end
person = Person.new("Ann", 30) # create an instance (calls initialize)
person.greet # "Hi, I'm Ann"
The initialize method is the constructor (called automatically by .new), and @name instance variables hold per-object state. Methods are defined with def.
class Person
attr_accessor :name # generates getter AND setter for @name
attr_reader :age # getter only (read-only)
def initialize(name, age)
@name = name
@age = age
end
end
person.name # "Ann" — getter
person.name = "Bob" # setter
Instance variables (@name) are private by default — you expose them with accessor methods. attr_accessor/attr_reader/attr_writer generate these getter/setter methods automatically (a Ruby convenience).
class Account
def deposit(amount) # public by default
update_balance(amount)
end
private # methods below are PRIVATE
def update_balance(amount)
@balance += amount
end
def self.create # CLASS method (self.) — called on the class, not an instance
new(...)
end
end
Account.create # class method
Methods are public by default; private/protected restrict access. def self.method defines a class method (called on the class itself).
Classes and objects are foundational to Ruby, which is a pure object-oriented language, so understanding them is essential for any Ruby development — virtually all Ruby code (and frameworks like Rails) is organized into classes.
Knowing how to define classes with the initialize constructor, use @instance variables for per-object state (and that they're private by default, requiring accessor methods to expose), define instance and class methods (def self.method), and apply access control (private/protected) is fundamental everyday knowledge.
A particularly important Ruby convenience is attr_accessor/attr_reader/attr_writer, which automatically generate getter/setter methods for instance variables — eliminating boilerplate and reflecting Ruby's elegance (instead of writing explicit getters/setters as in many languages, you declare them in one line).
Understanding Ruby's clean class syntax, the constructor and instance-variable model, accessor methods, and class methods is core, must-know material for object-oriented Ruby.
Since classes are how you model data and behavior throughout Ruby applications, and since Ruby's class features (the initialize convention, @ instance variables, attr_* accessors, public/private control) are how object-oriented Ruby is written, mastering them is essential, foundational knowledge that underpins all Ruby development and a frequent starting point for understanding the language's object-oriented nature.