Ruby unterstützt Single Inheritance (<) — eine Klasse erbt von einer Superklasse. Wenn Sie eine Methode aufrufen, durchsucht Ruby einen gut definierten Method Lookup Path (die Ancestor Chain, einschließlich gemischter Module) um sie zu finden. Das Verständnis dieses Pfads erklärt, wie Vererbung und Mixins Methoden auflösen.
() = = name
=
<
.new().speak
.new().fetch
Eine Subklasse (Dog < Animal) erbt die Methoden und Instanzvariablen der Superklasse und kann Methoden überschreiben. super ruft die Version der übergeordneten Klasse auf.
class Dog < Animal
def initialize(name, breed)
super(name) # call Animal#initialize
@breed = breed
end
def speak
super + " (woof)" # super (no parens) passes the same args; here calls Animal#speak
end
end
# Ruby searches for a method in this ORDER (the ancestors chain):
Dog.ancestors
# => [Dog, <included modules>, Animal, <Animal's modules>, Object, Kernel, BasicObject]
# lookup: the class itself → its included MODULES (last included first) →
# the superclass → ITS modules → ... up to BasicObject
Wenn Sie eine Methode aufrufen, durchläuft Ruby die Ancestor Chain (Class.ancestors): die Klasse selbst, dann ihre includierten Module (Mixins — zuletzt includierte zuerst), dann die Superklasse und ihre Module, bis zu BasicObject. Der erste Match gewinnt. Dieser einzelne Pfad erklärt, wie Vererbung UND Mixins zusammen aufgelöst werden.
module Swimmer
def move = "swimming"
end
class Fish < Animal
include Swimmer # Swimmer is inserted into the lookup path (before Animal)
end
# Fish.ancestors → [Fish, Swimmer, Animal, ...] — a module's methods come before the superclass's
Das Verständnis von Vererbung und dem Method Lookup Path ist wichtiges Ruby-Wissen sowohl für die Gestaltung von Klassenhierarchien als auch – insbesondere – um zu verstehen, wie Ruby Methoden auflöst, wenn Vererbung und Mixins kombiniert werden.
Rubys Single Inheritance (<) ermöglicht Wiederverwendung von Code durch "is-a"-Beziehungen mit super zum Aufrufen von Implementierungen der übergeordneten Klasse.
Aber das charakteristischere und wichtigere Konzept ist der Method Lookup Path (die Ancestor Chain): Wenn eine Methode aufgerufen wird, durchsucht Ruby in einer gut definierten Reihenfolge — die Klasse selbst, ihre includierten Module (Mixins, zuletzt includierte zuerst), dann die Superklasse und ihre Module, bis zu BasicObject — und der erste Match gewinnt.
Das Verständnis dieses einzelnen, einheitlichen Lookup Paths ist entscheidend, da es erklärt, wie Vererbung und Mixins zusammen aufgelöst werden (Module werden in die Chain eingefügt, ihre Methoden haben Vorrang vor denen der Superklasse), was ansonsten verwirrend wirkende Verhaltensweisen klärt, welche Methode tatsächlich aufgerufen wird, wenn Sie sowohl Vererbung als auch mehrere Mixins haben.
Dies ist besonders wichtig in Ruby, da es Mixins stark nutzt — zu wissen, dass Class.ancestors die genaue Lookup-Reihenfolge zeigt und wie Module darin passen, ermöglicht es Ihnen, Methoden-Auflösung zu verstehen und zu debuggen.
Das Verständnis von Vererbung, super und besonders des Method Lookup Paths (wie die Ancestor Chain Methoden über Klassen und gemischte Module hinweg auflöst) ist wichtiges, häufig relevantes Wissen für die Arbeit mit Rubys Klassensystem, zum Debuggen von "welche Methode wird aufgerufen?"-Fragen und zum Entwerfen von Klassen-/Modulsstrukturen – und es ist ein häufiges Interview-Thema, das tieferes Verständnis von Rubys Objektmodell und seiner charakteristischen Kombination von Single Inheritance mit mächtigen Mixins widerspiegelt.