Die Programmiersprache Ruby (German Edition)

Erstelle neue Klasse, weise Point zu
class Point # Öffne Klasse Point für neue Methoden
def add!(other) # Definiere Methode add!
    self.x += other.x
    self.y += other.y
    self
end
include Comparable # Nimm ein Modul für die Klasse mit auf
def <=>(other) # Definiere den Operator <=>
    return nil unless other.instance_of? Point
    self.x**2 + self.y**2 <=> other.x**2 + other.y**2
end
end
    Wie am Anfang dieses Abschnitts erwähnt wurde, ist die Klasse
Struct
dafür gedacht, veränderbare Klassen zu erstellen. Mit ein wenig Arbeit können wir aber eine
Struct
-basierte Klasse zu einer nicht veränderbaren machen:
Point = Struct.new(:x, :y) # Definiere veränderbare Klasse
class Point # Öffne die Klasse
undef x=,y=,[]= # Undefiniere die verändernden Methoden
end
    7.1.13 Eine Klassenmethode
    Lassen Sie uns eine andere Möglichkeit betrachten,
Point
-Objekte zu addieren: Anstatt eine Instanzmethode eines Punktes aufzurufen und dieser Methode einen anderen Punkt zu übergeben, wollen wir eine Methode namens
sum
schreiben, die eine beliebige Anzahl von
Point
-Objekten übernimmt, sie addiert und einen neuen
Point
zurückgibt. Diese Methode ist keine Instanzmethode, die für ein
Point
-Objekt aufgerufen wird. Vielmehr handelt es sich um eine Klassenmethode , die für die Klasse
Point
selbst aufgerufen wird. Wir können die Methode
sum
zum Beispiel so ansprechen:
total = Point.sum(p1, p2, p3) # p1, p2 und p3 sind Point-Objekte
    Denken Sie daran, dass sich der Ausdruck
Point
auf ein
Class
-Objekt bezieht, das unsere Punkt-Klasse repräsentiert. Zur Definition einer Klassenmethode für die
Point
-Klasse erstellen wir eine Singleton-Methode für das Objekt
Point
. (Wir haben Singleton-Methoden in „6.1.4 Singleton-Methoden definieren“ behandelt.) Um eine Singleton-Methode zu definieren, verwenden Sie die Anweisung
def
wie üblich, geben aber das Objekt, für das die Methode definiert werden soll, zusammen mit dem Namen der Methode an. Unsere Klassenmethode
sum
sieht so aus:
class Point
attr_reader :x, :y # Definiere Akzessormethoden für unsere Instanzvariablen
def Point.sum(*points) # Gib die Summe einer beliebigen Anzahl von Punkten zurück
    x = y = 0
    points.each {|p| x += p.x; y += p.y }
    Point.new(x,y)
end
# ... Rest der Klasse weggelassen ...
end
    Diese Definition der Klassenmethode benennt die Klasse explizit und spiegelt die Syntax wider, die zum Aufrufen der Methode verwendet wird. Klassenmethoden können auch über
self
statt über den Klassennamen definiert werden. Daher könnte diese Methode auch so geschrieben werden:
def self.sum(*points) # Gib die Summe einer beliebigen Anzahl von Punkten zurück
x = y = 0
points.each {|p| x += p.x; y += p.y }
Point.new(x,y)
end
    Durch die Verwendung von
self
statt von
Point
wird der Code zwar etwas weniger übersichtlich, ist aber eine Anwendung des Prinzips DRY (Don't Repeat Yourself). Wenn Sie statt des Klassennamens
self
nutzen, können Sie den Namen einer Klasse ändern, ohne die Definition jeder ihrer Klassenmethoden anpassen zu müssen.
    Es gibt noch eine weitere Technik für das Definieren von Klassenmethoden. Auch wenn sie nicht so übersichtlich wie die bisher vorgestellten Techniken ist, kann sie bei der Definition mehrerer Klassenmethoden praktisch sein — zudem wird sie Ihnen sicherlich in bestehendem Code über den Weg laufen:
# Öffne das Point-Objekt, so dass wir Methoden hinzufügen können
class << Point # Syntax zum Hinzufügen von Methoden zu einem einzelnen Objekt
def sum(*points) # Dies ist die Klassenmethode Point.sum.
    x = y = 0
    points.each {|p| x += p.x; y += p.y }
    Point.new(x,y)
end
# Andere Klassenmethoden können hier definiert werden.
end
    Diese Technik kann auch innerhalb der Klassendefinition genutzt werden, wo sich
self
verwenden lässt, statt den Klassennamen wiederholen zu müssen:
class Point
# Instanzmethoden
class << self
    # Klassenmethoden
end
end
    Wir werden mehr über diese Syntax in „7.7 Singleton-Methoden und die Eigenklasse“ lernen.
    7.1.14 Konstanten
    Viele Klassen profitieren von der Definition einiger passender Konstanten. Hier sehen Sie ein paar Konstanten, die für unsere Klasse
Point
nützlich sein können:
class Point
def initialize(x,y) # Initialize-Methode
    @x,@y = x, y
end
ORIGIN = Point.new(0,0)
UNIT_X = Point.new(1,0)
UNIT_Y = Point.new(0,1)
# Rest der Klassendefinition folgt hier
end
    Innerhalb der Klassendefinition können diese Konstanten über ihre nicht qualifizierten Namen angesprochen