Die Programmiersprache Ruby (German Edition)

lassen sich die Werte dieser Variablen nur über andere Instanzmethoden ansprechen. Wenn wir wollen, dass ein Anwender der Klasse
Point
auf die x - und y -Koordinaten eines Punktes zugreifen kann, müssen wir Akzessormethoden bereitstellen, die den Wert der Variablen zurückgeben:
class Point
def initialize(x,y)
    @x, @y = x, y
end
def x # Die Akzessor- (oder Getter-)Methode für @x
    @x
end
def y # Die Akzessormethode für @y
    @y
end
end
    Mit diesen Methoden können wir zum Beispiel folgenden Code schreiben:
p = Point.new(1,2)
q = Point.new(p.x*2, p.y*3)
    Die Ausdrücke
p.x
und
p.y
mögen vielleicht wie Variablenreferenzen aussehen, sind aber tatsächlich Methodenaufrufe ohne Klammern.
    Wenn wir wollten, dass sich unsere Klasse
Point
verändern lässt (was wahrscheinlich keine so gute Idee ist), würden wir auch noch Setter-Methoden hinzufügen, um den Wert der Instanzvariablen zu setzen:
class MutablePoint
def initialize(x,y); @x, @y = x, y; end
def x; @x; end # Die Getter-Methode für @x
def y; @y; end # Die Getter-Methode für @y
def x=(value) # Die Setter-Methode für @x
    @x = value
end
def y=(value) # Die Setter-Methode für @y
    @y = value
end
end
    Denken Sie daran, dass Zuweisungsausdrücke genutzt werden können, um solche Setter-Methoden aufzurufen. Daher können wir nun schreiben:
p = Point.new(1,1)
p.x = 0
p.y = 0
    Diese Kombination aus Instanzvariablen und einfachen Getter- und Setter-Methoden wird so häufig genutzt, dass Ruby eine Automatisierungsmöglichkeit bietet. Die Methoden
attr_reader
und
attr_accessor
werden durch die Klasse
Module
definiert. Alle Klassen sind Module (die Klasse
Class
ist eine Subklasse von
Module
), daher können Sie diese Methode innerhalb jeder Klassendefinition aufrufen. Beide Methoden erwarten eine beliebige Anzahl von Symbolen, die Attribute benennen.
attr_reader
erzeugt einfache Getter-Methoden für die Instanzvariablen mit dem gleichen Namen.
attr_accessor
erzeugt Getter- und Setter-Methoden. Wenn wir also eine veränderbare Klasse
Point
definieren wollten, könnten wir schreiben:
    ----
    Setter innerhalb einer Klasse verwenden
    Nachdem Sie einmal eine Setter-Methode wie
x=
für Ihre Klasse definiert haben, wollen Sie sie vielleicht auch innerhalb anderer Instanzmethoden Ihrer Klasse verwenden. Anstatt also
@x=2
zu schreiben, möchten Sie
x=2
nutzen und damit eigentlich
x=(2)
implizit für
self
aufrufen. Das funktioniert aber natürlich nicht —
x=2
erzeugt einfach eine neue lokale Variable.
    Das ist ein immer wieder vorkommender Fehler von Einsteigern, die gerade etwas über die Setter-Methoden und die Zuweisung in Ruby gelernt haben. Regel ist aber, dass Zuweisungsausdrücke nur dann eine Setter-Methode ansprechen, wenn sie über ein Objekt aufgerufen werden. Wenn Sie einen Setter innerhalb der ihn definierenden Klasse nutzen wollen, müssen Sie ihn explizit über
self
ansprechen, zum Beispiel:
self.x=2
.
    ----
class Point
attr_accessor :x, :y # Definiere Akzessor-Methoden für unsere Instanzvariablen
end
    Und wenn wir eine nicht veränderbare Version der Klasse haben wollten, würden wir schreiben:
class Point
attr_reader :x, :y # Definiere Lesemethoden für unsere Instanzvariablen
end
    Jede dieser Methoden kann einen oder mehrere Attributnamen auch als String statt als Symbol übernehmen. Üblich ist die Verwendung von Symbolen, aber wir könnten den Code auch so schreiben:
attr_reader "x", "y"
    attr
ist eine ähnliche Methode mit kürzerem Namen, aber einem Verhalten, das sich in Ruby 1.8 und Ruby 1.9 unterscheidet. In 1.8 kann
attr
nur ein einzelnes Attribut definieren, nicht mehrere gleichzeitig. Bei Angabe eines einzelnen Symbolarguments wird eine Getter-Methode definiert. Wenn dem Symbol der Wert
true
folgt, wird zudem eine Setter-Methode definiert:
attr :x # Definiert eine einfache Getter-Methode x für @x
attr :y, true # Definiert Getter- und Setter-Methoden für @y
    In Ruby 1.9 kann
attr
so wie in 1.8 oder als Synonym für
attr_reader
verwendet werden.
    Die Methoden
attr
,
attr_reader
und
attr_accessor
erzeugen für uns Instanzmethoden. Das ist ein Beispiel für Metaprogrammierung , ein mächtiges Feature von Ruby. Es gibt noch mehr Beispiele zur Metaprogrammierung in Kapitel 8 . Beachten Sie, dass
attr
und seine Kollegen innerhalb einer
class
-Definition, aber außerhalb jeder Methodendefinition aufgerufen werden. Sie werden nur einmal ausgeführt, wenn die Klasse definiert wird. Man muss sich dabei keine Sorgen um die Effizienz machen — die