Inicialização de hierarquia

7.1 Método super()

Já que tocamos na hierarquia de herança, é útil falar sobre os detalhes de se trabalhar com campos e métodos da classe base. Para isso, Python tem um método super(). Este método é usado para chamar métodos da classe base dentro da classe filha.

Existem três principais áreas de aplicação:

Chamada de métodos da classe pai:

O método super() permite chamar um método da classe pai a partir da classe filha, sem especificar explicitamente o nome da classe pai. Isso é especialmente útil ao trabalhar com herança múltipla e ajuda a evitar erros ao modificar a hierarquia de classes.

Inicialização de classes base:

super() é frequentemente usado no construtor da classe filha para chamar o construtor da classe base, permitindo inicializar atributos da classe base na classe filha.

Suporte a herança múltipla:

No caso de herança múltipla, super() resolve corretamente a ordem de chamadas de métodos (MRO, Method Resolution Order), tornando seu uso preferível a chamadas explícitas de métodos das classes pai. Falaremos sobre isso um pouco mais à frente.

7.2 Construtor da classe base

O construtor da classe base deve ser chamado explicitamente. Parece que isso acontece automaticamente, mas na verdade não é assim. Construtores de classes base sempre precisam ser chamados explicitamente, já que muitas vezes é necessário passar argumentos especiais.

Exemplo:

class Animal:
    def __init__(self, type, name):
        self.type = type
        self.name = name
         
        
class Dog(Animal):
    def __init__(self, name):
        super().__init__("Cachorro", name)  # Chama o construtor da classe base
        
class Cat(Animal):
    def __init__(self, name):
        super().__init__("Gato", name)  # Chama o construtor da classe base
        
        
# Criando um objeto Dog
dog = Dog("Buddy")
print(dog) 

Neste exemplo, o construtor da classe base (Animal) tem dois parâmetros: tipo do animal e o nome dele. Já as classes que herdaram têm apenas um — apenas o nome.

É precisamente nos construtores das classes Dog e Cat que se decide o que passar para o construtor da classe base — os nomes dos tipos de animais: “Cachorro” e “Gato”.

Assim:

• O construtor da classe base precisa ser chamado no construtor da classe filha.
• Para isso, precisamos usar o método super().
• Não é necessário passar o parâmetro self separadamente — Python o adiciona automaticamente ao chamar o método.

7.3 Uso do método super()

O método super() em Python pode ser usado não apenas nos construtores, mas também em outros métodos de classes para chamar métodos da classe pai. Isso pode ser útil quando é necessário estender ou modificar o comportamento de um método definido na classe pai.

Vamos ver alguns exemplos:

Chamando um método da classe pai em um método da filha

Neste exemplo, o método speak() na classe Dog primeiro chama o método speak() da classe Animal usando super(), e então adiciona seu próprio comportamento.

class Animal:
    def speak(self):
        return "Algum som genérico de animal"
        

class Dog(Animal):
    def speak(self):
        parent_speech = super().speak()  # Chama o método da classe pai
        return f"{parent_speech} E o cachorro late!"
        
dog = Dog()
print(dog.speak())  # Vai mostrar: Algum som genérico de animal E o cachorro late!

Chamada de método da classe pai para verificar estado

Neste exemplo, o método check_health() na classe Dog chama o método check_health() da classe Animal, para adicionar verificações adicionais.

class Animal:
    def check_health(self):
        return "Animal está saudável"
        

class Dog(Animal):
    def check_health(self):
        parent_check = super().check_health()  # Chama o método da classe pai
        return f"{parent_check}. O cachorro precisa de uma caminhada!"
        
dog = Dog()
print(dog.check_health())  # Vai mostrar: Animal está saudável. O cachorro precisa de uma caminhada!

Chamada de método da classe pai em um método que altera estado

Neste exemplo, o método withdraw() na classe SavingsAccount primeiro verifica se o limite de retirada foi excedido, e se não, chama o método withdraw() da classe BankAccount para realizar a operação.

class BankAccount:
    def __init__(self, balance):
        self.balance = balance
        

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            return f"Sacou {amount}. Novo saldo: {self.balance}"
        return "Fundos insuficientes"
        

class SavingsAccount(BankAccount):
    def withdraw(self, amount):
        if amount > 1000:
            return "Limite de retirada excedido"
        return super().withdraw(amount)  # Chama o método da classe pai
        

savings = SavingsAccount(1500)
print(savings.withdraw(500))  # Vai mostrar: Sacou 500. Novo saldo: 1000
print(savings.withdraw(1500))  # Vai mostrar: Limite de retirada excedido