Sobrescrever métodos

Redefinir o método na filha

Herdar dá à filha o comportamento da base. Mas às vezes a filha precisa fazer diferente. Todo animal faz um som, só que cada um faz o seu: o cachorro late, o gato mia. Em vez de inventar nomes diferentes para cada som, o mais elegante é manter um único método, digamos falar, e deixar cada filha dar a sua resposta a ele. Para isso a filha define um método falar com o mesmo nome do da base. Quando você chama falar num cachorro, o Python usa a versão de Cachorro; num gato, a de Gato. Isso é sobrescrever, ou fazer override.

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

    def falar(self):
        return f"{self.nome} faz um som."

class Cachorro(Animal):
    def falar(self):
        return f"{self.nome} faz au au!"

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

print(Animal("Bicho").falar())   # Bicho faz um som.
print(Cachorro("Rex").falar())   # Rex faz au au!
print(Gato("Felix").falar())     # Felix faz miau!

Cada filha redefine falar; o mesmo nome, três comportamentos.

As três classes têm um método falar, mas cada objeto responde do seu jeito. Lembre da resolução de método da aula sobre a classe filha: ao chamar rex.falar(), o Python procura falar primeiro em Cachorro, encontra ali e para; nunca chega à versão de Animal. Por isso a versão da filha substitui a da base para os objetos dela. A base ainda define um falar genérico, que serve de rede de segurança para qualquer filha que não sobrescreva. Esse é o começo do polimorfismo, que a próxima aula leva mais longe.

Completar a base com super

Sobrescrever não obriga a jogar fora a versão da base. Muitas vezes a filha quer fazer tudo o que a base faz e ainda um pouco mais. Nesse caso, ela chama a versão da base com super().metodo() e completa em seguida. É o mesmo super que você usou no construtor, agora aplicado a outro método. Pense num funcionário e num gerente: o gerente tem a mesma descrição básica do funcionário mais a informação do departamento que chefia. A filha não repete a descrição; ela pede a da base e acrescenta a sua parte.

class Funcionario:
    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario

    def descricao(self):
        return f"{self.nome}, salário R$ {self.salario}"

class Gerente(Funcionario):
    def __init__(self, nome, salario, setor):
        super().__init__(nome, salario)
        self.setor = setor

    def descricao(self):
        base = super().descricao()          # reaproveita a versão da base
        return f"{base}, gerente de {self.setor}"

g = Gerente("Ana", 9000, "Vendas")
print(g.descricao())  # Ana, salário R$ 9000, gerente de Vendas

Gerente sobrescreve descricao, mas chama super().descricao() para reaproveitar a base.

Onde o polimorfismo começa

Repare no que a sobrescrita permite: você chama falar sem saber, na hora, se o objeto é um cachorro ou um gato, e mesmo assim sai o som certo. Quem chama não precisa perguntar o tipo nem escrever uma cadeia de condições. O objeto sabe se comportar. Essa é a semente do polimorfismo, a próxima aula. Ela é possível porque toda filha compartilha o mesmo nome de método da base, e cada uma preenche esse nome com o seu comportamento. Nomes iguais na superfície, comportamentos diferentes por baixo.

class Animal:
    def __init__(self, nome):
        self.nome = nome
    def falar(self):
        return f"{self.nome} faz um som."

class Vaca(Animal):
    def falar(self):
        return f"{self.nome} faz muuu!"

def apresentar(animal):
    # não pergunta o tipo: confia no método falar
    print(animal.falar())

apresentar(Vaca("Mimosa"))    # Mimosa faz muuu!
apresentar(Animal("Bicho"))   # Bicho faz um som.

A função apresentar chama falar sem se importar com o tipo exato do objeto.

A função apresentar não sabe nem se importa se recebeu uma vaca ou um animal genérico; ela só chama falar e confia que cada objeto responde certo. Adicionar um novo tipo de animal, com o seu próprio falar, não obriga a mudar apresentar em nada. Esse desacoplamento é um dos maiores ganhos da orientação a objetos: código que trabalha com a ideia geral, e não com cada caso particular. Guarde o mecanismo: sobrescrever é redefinir o mesmo nome na filha, opcionalmente completando com super, e é ele que abre a porta do polimorfismo.