Ruby is puur object-gericht — je definieert klassen (blauwdrukken) en maakt objecten (instanties). Klassen gebruiken initialize als constructor, @variabelen voor instantietoestand, en toegangsmodificators voor inkapseling. Ruby's klassensyntax is schoon en expressief.
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"
De initialize methode is de constructor (automatisch aangeroepen door .new), en @name instantievariabelen houden per-object-toestand vast. Methoden worden gedefinieerd met 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
Instantievariabelen (@name) zijn standaard privé — je stelt ze bloot met accessor-methoden. attr_accessor/attr_reader/attr_writer genereren deze getter/setter-methoden automatisch (een Ruby-gemak).
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
Methoden zijn standaard openbaar; private/protected beperken toegang. def self.method definieert een klassemethode (aangeroepen op de klasse zelf).
Klassen en objecten zijn fundamenteel voor Ruby, wat een puur object-gericht taal is, dus het begrijpen ervan is essentieel voor alle Ruby-ontwikkeling — vrijwel alle Ruby-code (en frameworks zoals Rails) is in klassen georganiseerd.
Weten hoe je klassen definieert met de initialize constructor, @instance variabelen voor per-object-toestand gebruikt (en dat ze standaard privé zijn, wat accessor-methoden vereist om ze bloot te stellen), instantie- en klassmethoden definieert (def self.method), en toegangscontrole toepast (private/protected) is fundamentele dagelijkse kennis.
Een bijzonder belangrijk Ruby-gemak is attr_accessor/attr_reader/attr_writer, wat automatisch getter/setter-methoden voor instantievariabelen genereert — codestandaard elimineert en Ruby's elegantie weerspiegelt (in plaats van expliciete getters/setters te schrijven zoals in veel talen, declareer je ze in één regel).
Begrijpen van Ruby's schone klassensyntax, het constructor- en instantievariabelemodel, accessor-methoden, en klassmethoden is kernmateriaal, essentiële kennis voor object-gericht Ruby.
Omdat klassen hoe je data en gedrag in Ruby-applicaties modelleert, en omdat Ruby's klasseneigenschappen (de initialize conventie, @ instantievariabelen, attr_* accessors, openbaar/privé controle) hoe object-gericht Ruby wordt geschreven, is het beheersen ervan essentiële, fundamentele kennis die alle Ruby-ontwikkeling ondersteunt en een frequent startpunt is voor het begrijpen van de object-gerichte aard van de taal.