Ruby är rent objektorienterat — du definierar klasser (mallar) och skapar objekt (instanser). Klasser använder initialize som konstruktor, @variables för instanstillstånd och åtkomstmodifierare för inkapsling. Rubys klasssyntax är ren och uttrycksfull.
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"
Metoden initialize är konstruktorn (anropas automatiskt av .new), och @name instansvariabler innehåller per-objekt-tillstånd. Metoder definieras med 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
Instansvariabler (@name) är privata som standard — du exponerar dem med accessor-metoder. attr_accessor/attr_reader/attr_writer genererar dessa getter/setter-metoder automatiskt (en Rubybekvämlighet).
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
Metoder är publika som standard; private/protected begränsar åtkomsten. def self.method definierar en klassmetod (anropas på själva klassen).
Klasser och objekt är grundläggande för Ruby, vilket är ett rent objektorienterat språk, så att förstå dem är väsentligt för all Rubautveckling — praktiskt taget all Rubykod (och ramverk som Rails) är organiserad i klasser.
Att veta hur man definierar klasser med initialize-konstruktorn, använder @instance-variabler för per-objekt-tillstånd (och att de är privata som standard, vilket kräver accessor-metoder för att exponera), definierar instans- och klassmetoder (def self.method) och tillämpar åtkomstkontroll (private/protected) är grundläggande vardaglig kunskap.
En särskilt viktig Rubybekvämlighet är attr_accessor/attr_reader/attr_writer, som automatiskt genererar getter/setter-metoder för instansvariabler — vilket eliminerar boilerplate och återspeglar Rubys elegans (istället för att skriva explicita getters/setters som i många språk, deklarerar du dem på en rad).
Att förstå Rubys ren klasssyntax, konstruktor- och instansvariabelmodellen, accessor-metoder och klassmetoder är kärnmaterial, obligatorisk kunskap för objektorienterad Ruby.
Eftersom klasser är hur du modellerar data och beteende i hela Rubytillämpningar, och eftersom Rubys klassfunktioner (initialize-konventionen, @ instansvariabler, attr_* accessor-metoder, public/private-kontroll) är hur objektorienterad Ruby skrivs, är det väsentligt att behärska dem, grundläggande kunskap som ligger till grund för all Rubautveckling och är ofta en startpunkt för att förstå språkets objektorienterade natur.