Herança é um dos conceitos centrais da Programação Orientada a Objetos (OOP).
Ela permite que uma classe (chamada de filha ou subclasse) herde os atributos e métodos de outra classe (chamada de pai ou superclasse).

Isso significa que você pode definir comportamentos e dados comuns em uma classe base, e então criar classes mais especializadas que reutilizam e personalizam essa funcionalidade — sem precisar reescrever o mesmo código.

Sintaxe Básica para Herança

Em Python, a herança é implementada especificando o nome da classe pai entre parênteses após o nome da classe filha.

class ParentClass:
    # Atributos e métodos da classe pai

class ChildClass(ParentClass):
    # Atributos e métodos da classe filha
````

Quando uma classe filha herda de uma classe pai, ela recebe:

* Todos os **atributos** do pai (variáveis associadas ao objeto)
* Todos os **métodos** do pai (funções associadas ao objeto)
* Qualquer **construtor** (`__init__`) que a classe pai possua

---

# Exemplo: Animais e Sons

Vamos trazer a herança para um exemplo com que todos podemos nos identificar — animais.  
Começaremos com uma classe geral `Animal` que define o que todos os animais têm em comum, e então criaremos tipos específicos de animais (`Dog` e `Cat`) que compartilham essas características, mas fazem sons diferentes.

Aqui está a classe base:

```python
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sound(self):
        pass  # Vamos deixar que cada animal específico decida seu próprio som
````

A classe `Animal` tem:

* Um método `__init__` que configura o `name` e `age` para cada animal.
* Um método `sound()` que ainda não faz nada (`pass` é apenas um espaço reservado).
  Vamos substituí-lo em cada tipo de animal com o som que a espécie emite.

---

Agora, vamos criar duas classes específicas de animais:

```python
class Dog(Animal):
    def sound(self):
        print("Woof woof!")

class Cat(Animal):
    def sound(self):
        print("Meow!")

Aqui está o que está acontecendo:

• Tanto Dog quanto Cat herdam de Animal, então eles automaticamente possuem os atributos name e age sem precisarmos reescrever esse código.
• Cada um sobrescreve o método sound() para emitir seu som único.

Criando e Usando os Objetos

dog = Dog("Rex", 2)
cat = Cat("Mimi", 3)

print(dog.name)  # Rex
dog.sound()      # Woof woof!

print(cat.name)  # Mimi
cat.sound()      # Meow!

Quando criamos Dog("Rex", 2), o que acontece passo a passo é:

1. Python chama o método __init__ da classe Animal (porque Dog não tem um próprio).
2. Os valores name e age que passamos são armazenados naquele novo objeto.
3. Quando chamamos dog.sound(), Python procura primeiro um método sound() em Dog. Ele encontra o que escrevemos lá e executa — imprimindo "Woof woof!".

A mesma lógica vale para Cat, que encontra e executa seu próprio método sound().

Este exemplo mostra a magia da herança:

• Escrevemos apenas uma vez a configuração comum (__init__), na classe Animal.
• Cada subclasse (Dog, Cat) mantém as características compartilhadas e adiciona seu próprio comportamento único.
• O resultado é menos código repetitivo, lógica mais organizada e uma maneira mais fácil de gerenciar objetos relacionados.

3. Como Isto Funciona

• Estrutura compartilhada: O método __init__ da classe Animal é executado quando você cria um objeto Dog ou Cat, pois eles o herdam automaticamente.
• Sobrescrita de método: Tanto Dog quanto Cat têm seus próprios métodos sound() que substituem (override) o espaço reservado da classe Animal. Quando você chama sound() em um Dog, o Python usa o método definido em Dog, não o da classe Animal.

DICA: Se uma classe filha não sobrescrever um método, ela automaticamente usa o método da classe pai.

Por Que Usar Herança?

A herança permite:

• Evitar repetir código colocando a lógica compartilhada em uma única classe base.
• Tornar seu código mais modular e legível.
• Construir classes especializadas a partir de uma planta geral.

Exemplo de pensamento em herança:

• Animal → planta geral com name, age, e um método sound().
• Dog → tipo específico de animal com som único.
• Cat → outro tipo específico de animal com som diferente.

Conclusão

Herança é uma ferramenta poderosa na OOP para criar hierarquias de classes, partindo de conceitos gerais e avançando para os mais especializados.

Em Python, você a implementa:

1. Escrevendo uma classe pai com atributos e métodos comuns.
2. Criando classes filhas que listam o nome da classe pai entre parênteses.
3. Adicionando ou sobrescrevendo métodos nas classes filhas conforme necessário.

Na próxima lição, vamos aprofundar esse conceito explorando o super() — uma forma para as classes filhas chamarem e estenderem o comportamento de suas classes pai.