Ruby este pur orientat pe obiecte — definești clase (șabloane) și creezi obiecte (instanțe). Clasele folosesc initialize ca constructor, @variables pentru starea instanței, și modificatori de acces pentru încapsulare. Sintaxa claselor în Ruby este curată și expresivă.
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"
Metoda initialize este constructorul (apelată automat de .new), iar variabilele de instanță @name dețin starea specifică fiecărui obiect. Metodele sunt definite cu 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
Variabilele de instanță (@name) sunt private implicit — le expui cu metode accessor. attr_accessor/attr_reader/attr_writer generează automat aceste metode getter/setter (o comoditate 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
Metodele sunt publice implicit; private/protected restricționează accesul. def self.method definește o metodă de clasă (apelată pe clasa în sine).
Classele și obiectele sunt fundamentale pentru Ruby, care este un limbaj pur orientat pe obiecte, deci înțelegerea lor este esențială pentru orice dezvoltare în Ruby — practic întregul cod Ruby (și framework-uri precum Rails) este organizat în clase.
A ști cum să definești clase cu constructorul initialize, să folosești variabilele @instance pentru starea specifică fiecărui obiect (și că sunt private implicit, necesitând metode accessor pentru a le expune), să definești metode de instanță și metode de clasă (def self.method), și să aplici controlul accesului (private/protected) este cunoaștere fundamentală de zi cu zi.
O comoditate Ruby deosebit de importantă este attr_accessor/attr_reader/attr_writer, care generează automat metode getter/setter pentru variabilele de instanță — eliminând codul repetat și reflectând eleganța Ruby (în loc să scrii getteri/setteri expliciti ca în multe alte limbaje, le declari pe toate într-o singură linie).
Înțelegerea sintaxei curate a claselor din Ruby, modelul constructor și variabilă de instanță, metodele accessor, și metodele de clasă este material central, pe care trebuie să-l cunoști pentru Ruby orientat pe obiecte.
Deoarece clasele sunt cum modelezi date și comportament în aplicațiile Ruby, și deoarece caracteristicile claselor din Ruby (convenția initialize, variabilele de instanță cu @, accesorii attr_*, controlul public/private) sunt cum se scrie Ruby orientat pe obiecte, stăpânirea lor este cunoaștere esențială și fundamentală care susține toată dezvoltarea în Ruby și este adesea un punct de plecare pentru înțelegerea naturii orientate pe obiecte a limbajului.