Ruby suporta herança simples (<) — uma classe herda de uma única superclasse. Quando você chama um método, Ruby busca em um caminho de busca de métodos bem definido (a cadeia de ancestrais, incluindo módulos misturados) para encontrá-lo. Compreender este caminho explica como herança e mixins resolvem métodos.
() = = name
=
<
.new().speak
.new().fetch
Uma subclasse (Dog < Animal) herda os métodos e variáveis de instância da superclasse, e pode sobrescrever métodos. super chama a versão do pai.
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
Quando você chama um método, Ruby percorre a cadeia de ancestrais (Class.ancestors): a classe em si, depois seus módulos incluídos (mixins — os mais recentemente incluídos primeiro), depois a superclasse e seus módulos, até BasicObject. O primeiro encontrado vence. Este caminho único explica como herança E mixins resolvem juntos.
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
Compreender herança e o caminho de busca de métodos é conhecimento importante de Ruby tanto para projetar hierarquias de classes quanto — especialmente — para entender como Ruby resolve métodos quando herança e mixins se combinam.
A herança simples (<) de Ruby fornece reutilização de código via relações "é-um", com super para chamar implementações do pai.
Mas o conceito mais distintivo e importante é o caminho de busca de métodos (a cadeia de ancestrais): quando um método é chamado, Ruby busca em uma ordem bem definida — a classe em si, seus módulos incluídos (mixins, os mais recentemente incluídos primeiro), depois a superclasse e seus módulos, até BasicObject — e o primeiro encontrado vence.
Compreender este caminho de busca único e unificado é crucial porque explica como herança e mixins resolvem juntos (módulos são inseridos na cadeia, seus métodos tendo precedência sobre os da superclasse), o que esclarece comportamentos confusos sobre qual método realmente é chamado quando você tem tanto herança quanto múltiplos mixins.
Isso é particularmente importante em Ruby dado o quão intensamente ele usa mixins — saber que Class.ancestors mostra a ordem exata de busca, e como módulos se encaixam nela, permite raciocinar e depurar a resolução de métodos.
Compreender herança, super, e especialmente o caminho de busca de métodos (como a cadeia de ancestrais resolve métodos através de classes e módulos misturados) é conhecimento importante e frequentemente relevante para trabalhar com o sistema de classes do Ruby, depurar questões "qual método está sendo chamado?", e projetar hierarquias de classe/módulo — e é um tópico comum em entrevistas que reflete compreensão mais profunda do modelo de objetos do Ruby e sua combinação distintiva de herança simples com mixins poderosos.