Die Programmiersprache Ruby (German Edition)

so erzeugten Getter- und Setter-Methoden sind genauso schnell wie die von Hand geschriebenen. Denken Sie daran, dass diese Methoden nur triviale Getter und Setter erstellen können, die den Wert einer Instanzvariablen mit dem gleichen Namen abbilden. Wenn Sie kompliziertere Akzessoren benötigen, wie zum Beispiel Setter, die eine Variable mit einem anderen Namen setzen, oder Getter, die einen aus zwei verschiedenen Variablen berechneten Wert zurückgeben, müssen Sie sie selber schreiben.
    7.1.6 Definieren von Operatoren
    Wir würden gern den Operator
+
nutzen, um die Vektoraddition zweier
Point
-Objekte durchzuführen, den Operator
*
für die Multiplikation eines
Point
mit einem Skalarwert und den unären Operator – für eine Multiplikation des Punktes mit
−1
. Methodenbasierte Operatoren wie
+
sind einfach Methoden mit Satzzeichen als Namen. Da es unäre und binäre Formen des Operators – gibt, nutzt Ruby den Methodennamen
-@
für das unäre Minus. Hier sehen Sie eine Version der Klasse
Point
mit mathematischen Operatoren:
class Point
attr_reader :x, :y # Definiert Akzessor-Methoden für unsere Instanzvariablen
def initialize(x,y)
    @x,@y = x, y
end
def +(other) # Definiert + für eine Vektoraddition
    Point.new(@x + other.x, @y + other.y)
end
def -@ # Definiert das unäre Minus, um beide Koordinaten zu
     # negieren
    Point.new(-@x, -@y)
end
def *(scalar) # Definiert * für eine skalare Multiplikation
    Point.new(@x*scalar, @y*scalar)
end
end
    Schauen Sie sich den Rumpf der Methode
+
an. Sie kann die Instanzvariable
@x
von
self
nutzen — dem Objekt, für das die Methode aufgerufen wurde. Aber sie kann nicht auf
@x
des anderen
Point
-Objekts zugreifen. Ruby hat dafür keine Syntax, alle Instanzvariablen beziehen sich implizit auf
self
. Unsere Methode
+
muss daher auf die
x
- und
y
-Getter-Methoden zugreifen. (Wir werden später noch sehen, dass es möglich ist, die Sichtbarkeit von Methoden so einzuschränken, dass Objekte derselben Klasse gegenseitig die jeweils anderen Methoden aufrufen können, Code außerhalb der Klasse das aber nicht darf.)
    Beachten Sie, dass unsere Methode
*
einen numerischen Operanden erwartet, keinen
Point
. Wenn
p
ein Punkt ist, können wir
p*2
schreiben. So wie unsere Klasse geschrieben ist, können wir allerdings nicht
2*p
schreiben. Dieser zweite Ausdruck ruft die Methode
*
der Klasse
Integer
auf, die nicht weiß, wie sie mit
Point
-Objekten umgehen soll. In so einem Fall fragt sie
Point
um Hilfe — über die Methode
coerce
. (Siehe „3.8.7.4 Typ-Erzwingung für arithmetische Operatoren“ für mehr Details.) Wenn wir wollen, dass der Ausdruck
2*p
zum selben Ergebnis führt wie
p*2
, können wir die Methode
coerce
definieren:
    ----
    Typprüfung und Duck Typing
    Unsere Methode
+
nimmt keine Typprüfung vor — sie geht einfach davon aus, dass ihr ein passendes Objekt übergeben wurde. Es ist in der Ruby-Programmierung ziemlich weit verbreitet, bei der Definition von »passend« recht leger zu sein. Bei unserer Methode
+
passen alle Objekte, die Methoden mit den Namen
x
und
y
besitzen, solange diese Methoden keine Argumente erwarten und irgendeine Zahl zurückgeben. Wir kümmern uns nicht darum, ob das Argument tatsächlich ein Punkt ist , solange es so aussieht und sich so verhält. Dieses Vorgehen wird manchmal als »Duck Typing« bezeichnet, entsprechend dem angelsächsischen Sprichwort »Wenn etwas wie eine Ente läuft und wie eine Ente quakt, muss es eine Ente sein.«
    Wenn wir
+
ein Objekt übergeben, das nicht passt, wird Ruby eine Exception werfen. Versuchen wir zum Beispiel, zu einem Punkt eine
3
zu addieren, erhalten wir folgende Fehlermeldung:
NoMethodError: undefined method `x' for 3:Fixnum
     from ./point.rb:37:in `+'
    Übersetzt heißt das, dass die
Fixnum 3
keine Methode mit dem Namen
x
besitzt und dieser Fehler in der Methode
+
der Klasse
Point
aufgetreten ist. Das sind genug Informationen, um den Ursprung des Problems herauszufinden, aber trotzdem ist es ein wenig obskur. Wenn die Klasse von Methodenargumenten geprüft wird, kann es leichter sein, Code zu debuggen, der diese Methode verwendet. Hier sehen Sie eine Version einer Methode mit einer Klassenverifikation:
def +(other)
raise TypeError, "Point-Argument erwartet" unless other.is_a? Point
Point.new(@x + other.x, @y + other.y)
end
    Das hier ist eine etwas generösere Version der Typprüfung, die verbesserte Fehlermeldungen bereitstellt und dazu Duck Typing erlaubt:
def +(other)
raise TypeError,