Die Programmiersprache Ruby (German Edition)

Objekt ist eine Instanz einer Klasse. Eine Klasse definiert eine Reihe von Methoden, auf die ein Objekt reagiert. Klassen können andere Klassen erweitern oder Subklassen von ihnen bilden und die Methoden ihrer Superklassen erben oder überschreiben. Klassen können zudem Module enthalten – oder Methoden davon übernehmen.
    Die Objekte sind in Ruby strikt gekapselt: Auf ihren Zustand kann nur über die Methoden zugegriffen werden, die sie definieren. Die durch solche Methoden veränderten Instanzvariablen können nicht von außerhalb des Objekts angesprochen werden. Es ist möglich, Getter- und Setter-Zugriffsmethoden zu definieren, die einen direkten Zugriff auf den Objektzustand zu ermöglichen scheinen. Diese Paare von Akzessormethoden sind als Attribute bekannt und unterscheiden sich von Instanzvariablen. Die Methoden, die durch eine Klasse definiert werden, können eine öffentliche (»public«), geschützte (»protected«) oder private (»private«) Sichtbarkeit haben, durch die bestimmt wird, wie und wo sie angesprochen werden können.
    Im Gegensatz zur strikten Kapselung des Objektzustands sind die Klassen in Ruby sehr offen. Jedes Ruby-Programm kann bestehenden Klassen Methoden hinzufügen, und es ist sogar möglich, einzelne Objekte um »Singleton-Methoden« zu ergänzen.
    Ein Großteil der OO-Architektur von Ruby ist Teil des Sprachkerns. Andere Sachen, wie zum Beispiel das Erzeugen von Attributen und die Deklaration der Sichtbarkeit von Methoden, werden über Methoden und nicht über echte Schlüsselwörter umgesetzt. Dieses Kapitel beginnt mit einem ausführlichen Tutorial, das zeigt, wie man eine Klasse definiert und ihr Methoden hinzufügt. Danach folgen Abschnitte über fortgeschrittenere Themen, wie zum Beispiel
    Sichtbarkeit von Methoden
Subklassen und Vererbung
Erzeugen und Initialisieren von Objekten
Module als Namensräume und als »Mixins«, die eingebunden werden können
Singleton-Methoden und die Eigenklasse
Algorithmus zur Auflösung von Methodennamen
Algorithmus zur Auflösung von Namen von Konstanten

7.1 Definieren einer einfachen Klasse
    Wir beginnen unsere Behandlung von Klassen mit einem umfangreichen Tutorium, in dem eine Klasse namens
Point
entwickelt wird, um einen geometrischen Punkt durch x - und y -Koordinaten zu repräsentieren. Die folgenden Abschnitte zeigen Ihnen, wie Sie
    eine neue Klasse definieren,
Instanzen dieser Klasse erzeugen,
eine Initialisierermethode für die Klasse schreiben,
Attributszugriffsmethoden hinzufügen,
Operatoren für die Klasse definieren,
eine Iterator-Methode festlegen und die Klasse enumerierbar (
Enumerable
) machen,
wichtige Objektmethoden überschreiben, wie zum Beispiel
to_s
,
==
,
hash
und
<=>
, und
Klassenmethoden, Klassenvariablen, Klasseninstanzvariablen und Konstanten definieren.
    7.1.1 Erstellen der Klasse
    Klassen werden in Ruby mit dem Schlüsselwort
class
definiert:
class Point
end
    Wie die meisten Ruby-Konstrukte wird eine Klassendefinition durch ein
end
abgeschlossen. Dabei definiert das Schlüsselwort
class
nicht nur eine neue Klasse, sondern auch noch eine Konstante, die auf die Klasse verweist. Der Name der Klasse und der Konstante sind identisch, daher müssen alle Klassennamen mit einem Großbuchstaben beginnen.
    Innerhalb des Rumpfes einer
class
, aber außerhalb jeder Instanzmethode, die durch die Klasse definiert wird, bezieht sich das Schlüsselwort
self
auf die definierte Klasse.
    Wie die meisten Anweisungen in Ruby ist
class
ein Ausdruck. Der Wert eines
class
-Ausdrucks ist der Wert der letzten Zuweisung innerhalb des Rumpfes von
class
. Üblicherweise ist der letzte Ausdruck in einer Klasse eine
def
-Anweisung, die eine Methode definiert. Der Wert einer solchen
def
-Anweisung ist immer
nil
.
    7.1.2 Instanziieren eines Point
    Obwohl wir bisher noch nichts in unsere Klasse
Point
gesteckt haben, können wir sie schon instanziieren:
p = Point.new
    Die Konstante
Point
enthält ein Klassenobjekt, das unsere neue Klasse darstellt. Alle Klassenobjekte besitzen eine Methode namens
new
, die eine neue Instanz erzeugt.
    Wir können mit unserem neu erzeugten
Point
-Objekt, das wir in der lokalen Variablen
p
untergebracht haben, noch nicht viel Interessantes anfangen, da wir noch keine Methoden für die Klasse definiert haben. Aber wir können das neue Objekt schon fragen, was für ein Typ es ist:
p.class # => Point
p.is_a? Point # => true
    7.1.3 Initialisieren eines Point
    Wenn wir neue
Point
-Objekte erzeugen, wollen wir sie mit