Ruby é puramente orientado a objetos — você define classes (modelos) e cria objetos (instâncias). Classes usam initialize como construtor, @variables para estado da instância, e modificadores de acesso para encapsulamento. A sintaxe de classes do Ruby é limpa e expressiva.
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"
O método initialize é o construtor (chamado automaticamente por .new), e as variáveis de instância @name armazenam o estado por objeto. Métodos são definidos com 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
Variáveis de instância (@name) são privadas por padrão — você as expõe com métodos acessores. attr_accessor/attr_reader/attr_writer geram automaticamente esses métodos getter/setter (uma conveniência do Ruby).
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
Métodos são públicos por padrão; private/protected restringem o acesso. def self.method define um método de classe (chamado na classe em si).
Classes e objetos são fundamentais no Ruby, que é uma linguagem puramente orientada a objetos, portanto compreendê-los é essencial para qualquer desenvolvimento em Ruby — praticamente todo código Ruby (e frameworks como Rails) está organizado em classes.
Saber como definir classes com o construtor initialize, usar variáveis @instance para estado por objeto (e que elas são privadas por padrão, exigindo métodos acessores para expô-las), definir métodos de instância e métodos de classe (def self.method), e aplicar controle de acesso (private/protected) é conhecimento fundamental do dia a dia.
Uma conveniência particularmente importante do Ruby é attr_accessor/attr_reader/attr_writer, que geram automaticamente métodos getter/setter para variáveis de instância — eliminando boilerplate e refletindo a elegância do Ruby (em vez de escrever getters/setters explícitos como em muitas linguagens, você os declara em uma única linha).
Compreender a sintaxe limpa de classes do Ruby, o modelo de construtor e variáveis de instância, métodos acessores e métodos de classe é material fundamental e essencial para Ruby orientado a objetos.
Como classes são como você modela dados e comportamento em aplicações Ruby, e como as funcionalidades de classe do Ruby (a convenção initialize, variáveis de instância @, acessores attr_*, controle público/privado) são como Ruby orientado a objetos é escrito, dominá-las é conhecimento essencial e fundamental que sustenta todo desenvolvimento em Ruby e é frequentemente um ponto de partida para compreender a natureza orientada a objetos da linguagem.