Herencia es uno de los conceptos fundamentales de la Programación Orientada a Objetos (OOP).
Permite que una clase (llamada hija o subclase) herede los atributos y métodos de otra clase (llamada padre o superclase).

Esto significa que puedes definir comportamientos y datos comunes en una clase base, y luego crear clases más especializadas que reutilicen y personalicen esa funcionalidad — sin tener que reescribir el mismo código.

Sintaxis Básica para la Herencia

En Python, la herencia se implementa especificando el nombre de la clase padre entre paréntesis después del nombre de la clase hija.

class ParentClass:
    # Atributos y métodos de la clase padre

class ChildClass(ParentClass):
    # Atributos y métodos de la clase hija
````

Cuando una clase hija hereda de una clase padre, obtiene:

* Todos los **atributos** del padre (variables vinculadas al objeto)
* Todos los **métodos** del padre (funciones vinculadas al objeto)
* Cualquier **constructor** (`__init__`) que tenga la clase padre

---

# Ejemplo: Animales y Sonidos

Vamos a dar vida a la herencia con algo con lo que todos podemos relacionarnos — los animales.  
Comenzaremos con una clase general `Animal` que define lo que todos los animales tienen en común, y luego crearemos tipos específicos de animales (`Dog` y `Cat`) que comparten esos rasgos pero emiten sonidos diferentes.

Aquí está la clase base:

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

    def sound(self):
        pass  # Dejamos que cada animal específico decida su propio sonido
````

La clase `Animal` tiene:

* Un método `__init__` que define el `name` y `age` para cada animal.
* Un método `sound()` que aún no hace nada (`pass` es solo un marcador de posición).
  Lo reemplazaremos en cada tipo de animal con el sonido de esa especie.

---

Ahora creemos dos clases de animales específicas:

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

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

Esto es lo que sucede:

• Tanto Dog como Cat heredan de Animal, por lo que obtienen automáticamente los atributos name y age sin que tengamos que reescribir ese código.
• Cada uno sobrescribe el método sound() para producir su propio sonido único.

Creando y Usando los Objetos

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

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

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

Cuando creamos Dog("Rex", 2), esto pasa paso a paso:

1. Python llama al método __init__ de Animal (porque Dog no tiene uno propio).
2. Los valores de name y age que pasamos se almacenan en ese nuevo objeto.
3. Cuando llamamos a dog.sound(), Python busca primero un método sound() en Dog. Encuentra el que escribimos ahí y lo ejecuta — imprimiendo "Woof woof!".

La misma lógica se aplica a Cat, pero encuentra y ejecuta su propio método sound().

Este ejemplo muestra la magia de la herencia:

• Escribimos la configuración común (__init__) solo una vez, en la clase Animal.
• Cada subclase (Dog, Cat) conserva las características compartidas y añade su comportamiento único.
• El resultado es código menos repetitivo, lógica más organizada y una forma más fácil de gestionar objetos relacionados.

3. Cómo Funciona Esto

• Estructura compartida: El método __init__ de Animal se ejecuta cuando creas un objeto Dog o Cat, porque lo heredan automáticamente.
• Sobrescritura de métodos: Tanto Dog como Cat tienen sus propios métodos sound() que reemplazan (sobrescriben) el marcador de posición en Animal. Cuando llamas a sound() en un Dog, Python usa el definido en Dog, no el de Animal.

CONSEJO: Si una clase hija no sobrescribe un método, usa automáticamente el de la clase padre.

¿Por Qué Usar Herencia?

La herencia te permite:

• Evitar repetir código poniendo la lógica compartida en una única clase base.
• Hacer tu código más modular y legible.
• Construir clases especializadas a partir de un modelo general.

Ejemplo de pensamiento en herencia:

• Animal → modelo general con name, age y un método sound().
• Dog → tipo específico de animal con un sonido único.
• Cat → otro tipo específico de animal con un sonido distinto.

Conclusión

La herencia es una herramienta poderosa en OOP para crear una jerarquía de clases, empezando con conceptos generales y avanzando hacia otros más especializados.

En Python, la implementas:

1. Escribiendo una clase padre con atributos y métodos comunes.
2. Creando clases hijas que listan el nombre de la clase padre entre paréntesis.
3. Añadiendo o sobrescribiendo métodos en las clases hijas según sea necesario.

En la próxima lección, profundizaremos en este concepto explorando super() — una forma para que las clases hijas llamen y amplíen el comportamiento de sus clases padre.