Ruby ist rein objektorientiert — Sie definieren Klassen (Vorlagen) und erstellen Objekte (Instanzen). Klassen nutzen initialize als Konstruktor, @variables für den Instanzzustand und Zugriffsbeschränkungen für Kapselung. Rubys Klassensyntax ist sauber und ausdrucksstark.
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"
Die initialize-Methode ist der Konstruktor (wird automatisch durch .new aufgerufen), und @name Instanzvariablen halten den Zustand pro Objekt. Methoden werden mit def definiert.
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
Instanzvariablen (@name) sind standardmäßig privat — Sie stellen sie über Accessormethoden bereit. attr_accessor/attr_reader/attr_writer generieren diese Getter-/Setter-Methoden automatisch (eine Ruby-Vereinfachung).
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 sind standardmäßig öffentlich; private/protected beschränken den Zugriff. def self.method definiert eine Klassenmethode (wird auf der Klasse selbst aufgerufen).
Klassen und Objekte sind grundlegend für Ruby, das eine rein objektorientierte Sprache ist, daher ist ihr Verständnis für jede Ruby-Entwicklung essentiell — praktisch der gesamte Ruby-Code (und Frameworks wie Rails) ist in Klassen organisiert.
Zu wissen, wie man Klassen mit dem initialize Konstruktor definiert, @instance Variablen für den Zustand pro Objekt verwendet (und dass sie standardmäßig privat sind und Accessormethoden benötigen, um sie bereitzustellen), Instanzmethoden und Klassenmethoden definiert (def self.method) und Zugriffskontrolle anwendet (private/protected), ist fundamentales alltägliches Wissen.
Eine besonders wichtige Ruby-Vereinfachung ist attr_accessor/attr_reader/attr_writer, das automatisch Getter-/Setter-Methoden für Instanzvariablen generiert — wodurch Boilerplate eliminiert wird und Rubys Eleganz widergespiegelt wird (anstatt explizite Getter/Setter wie in vielen anderen Sprachen zu schreiben, deklarieren Sie diese in einer Zeile).
Das Verständnis von Rubys sauberer Klassensyntax, dem Konstruktor- und Instanzvariablen-Modell, Accessormethoden und Klassenmethoden ist Kernmaterial und muss-wissen-Material für objektorientiertes Ruby.
Da Klassen die Art sind, wie Sie Daten und Verhalten in Ruby-Anwendungen modellieren, und da Rubys Klassenfunktionen (die initialize Konvention, @ Instanzvariablen, attr_* Accessoren, öffentlich/privat Kontrolle) so objektorientiertes Ruby geschrieben wird, ist deren Beherrschung essentielles, fundamentales Wissen, das alle Ruby-Entwicklung untermauert und oft ein Ausgangspunkt für das Verständnis der objektorientierten Natur der Sprache ist.