Criando uma classe filha

A sintaxe da classe filha

A herança em Python cabe em um detalhe de sintaxe: você coloca o nome da classe base entre parênteses logo depois do nome da filha. Onde antes você escrevia class Cachorro:, agora escreve class Cachorro(Animal):. Esse par de parênteses é o que diz ao Python que Cachorro deve reaproveitar tudo de Animal. Sem os parênteses, Cachorro seria uma classe independente, sem nenhuma ligação com Animal. Com eles, a ligação está feita e a herança acontece.

class Veiculo:
    def __init__(self, marca):
        self.marca = marca

    def ligar(self):
        return f"{self.marca} ligado."

class Carro(Veiculo):
    def buzinar(self):
        return "Bi bi!"

meu = Carro("Fiat")
print(meu.marca)      # Fiat
print(meu.ligar())    # Fiat ligado.
print(meu.buzinar())  # Bi bi!

Carro(Veiculo) herda marca e ligar, e adiciona buzinar.

O objeto meu foi criado como Carro, mas responde a marca e a ligar sem que Carro tenha definido nenhum dos dois; os dois vieram de Veiculo. E buzinar, que é próprio de Carro, também funciona. Repare que nem sequer escrevemos um __init__ em Carro: como a filha não define o seu próprio construtor, o Python usa o da base. Por isso Carro("Fiat") funciona e o atributo marca é criado. Na próxima aula você aprende a estender esse construtor quando a filha precisar de dados a mais.

Acrescentando o que é próprio da filha

A filha não fica presa ao que a base oferece. Ela pode acrescentar quantos métodos quiser, e cada filha pode acrescentar coisas diferentes. É assim que duas classes que herdam da mesma base se especializam em direções distintas. No exemplo abaixo, tanto Gato quanto Passaro herdam de Animal, ganhando nome e comer, mas cada um define o seu próprio comportamento: o gato mia e o pássaro voa. A base concentra o comum; as filhas concentram a diferença.

class Animal:
    def __init__(self, nome):
        self.nome = nome

    def comer(self):
        return f"{self.nome} comeu."

class Gato(Animal):
    def miar(self):
        return f"{self.nome}: miau"

class Passaro(Animal):
    def voar(self):
        return f"{self.nome} voou."

felix = Gato("Felix")
blu = Passaro("Blu")
print(felix.comer(), felix.miar())  # Felix comeu. Felix: miau
print(blu.comer(), blu.voar())      # Blu comeu. Blu voou.

Duas filhas da mesma base, cada uma com o seu método próprio.

Como o Python encontra o método

Quando você escreve felix.comer(), o Python faz uma busca ordenada. Ele olha primeiro na classe do objeto, que é Gato. Não achou comer ali, então sobe para a classe base, Animal, e encontra. Se também não achasse em Animal, continuaria subindo até acabar a cadeia e, aí sim, daria um erro de atributo. Essa ordem, da classe mais específica para a mais geral, chama-se resolução de método. Você não precisa decorar o mecanismo agora, mas entender que a busca vai da filha para a base explica por que a filha pode redefinir um método da base, tema da aula sobre sobrescrever.

class Animal:
    def comer(self):
        return "Animal comendo"

class Gato(Animal):
    pass  # não define nada; herda tudo

felix = Gato()
print(felix.comer())          # Animal comendo
print(isinstance(felix, Gato))    # True
print(isinstance(felix, Animal))  # True

Gato vazio herda comer de Animal; felix é dos dois tipos ao mesmo tempo.

O último trecho revela algo importante: um Gato é, ao mesmo tempo, um Animal. A função isinstance confirma que felix é instância de Gato e também de Animal, exatamente a relação é-um da aula anterior, agora visível em código. Essa dupla identidade é o que torna possível o polimorfismo, que você verá adiante: como todo Gato é um Animal, qualquer trecho que espere um Animal aceita um Gato. Por enquanto, fixe a mecânica: parênteses com a base para herdar, métodos novos na filha para especializar, e busca da filha para a base ao chamar.