Tema 3 5to Secundaria

 El polimorfismo es uno de los cuatro pilares fundamentales de la programación orientada a objetos (junto con encapsulación, herencia y abstracción). En Python, el polimorfismo se refiere a la capacidad de objetos de diferentes clases de responder al mismo mensaje (método) de manera específica.

¿Qué significa polimorfismo?

La palabra "polimorfismo" viene del griego: "poli" (muchas) y "morphos" (formas). Literalmente significa "muchas formas".

En programación, esto se traduce en que:

• Diferentes objetos pueden tener métodos con el mismo nombre

• Cada objeto implementa el método de forma particular

• Podemos tratar objetos de diferentes clases de manera uniforme

Ventajas del polimorfismo

• Flexibilidad: Podemos agregar nuevas clases sin modificar el código existente

• Reutilización: El mismo código funciona con diferentes tipos de objetos

• Mantenibilidad: Código más limpio y fácil de entender

• Extensibilidad: Fácil agregar nuevos comportamientos

Herencia en Python
La herencia es un mecanismo que permite crear nuevas clases basadas en clases existentes, permitiendo reutilizar código y establecer relaciones jerárquicas..
Sintaxis Básica
python
class ClasePadre:
    # atributos y métodos de la clase padre
    pass

class ClaseHija(ClasePadre):  # Herencia simple
    # atributos y métodos de la clase hija
    pass
1. Herencia Simple
python
class Animal:
    def __init__(self, nombre):
        self.nombre = nombre
    
    def hacer_sonido(self):
        return "Sonido genérico"
    
    def dormir(self):
        return f"{self.nombre} está durmiendo"

class Perro(Animal):  # Perro hereda de Animal
    def hacer_sonido(self):  # Sobrescritura de método
        return "¡Guau!"

# Uso
mi_perro = Perro("Rex")
print(mi_perro.nombre)        # Rex (heredado)
print(mi_perro.hacer_sonido()) # ¡Guau! (sobrescrito)
print(mi_perro.dormir())      # Rex está durmiendo (heredado)
2. Herencia Multinivel
python
class Vehiculo:
    def __init__(self, marca):
        self.marca = marca
    
    def mover(self):
        return "El vehículo se mueve"

class Coche(Vehiculo):
    def __init__(self, marca, puertas):
        super().__init__(marca)
        self.puertas = puertas
    
    def abrir_puertas(self):
        return f"Abriendo {self.puertas} puertas"

class CocheElectrico(Coche):
    def __init__(self, marca, puertas, autonomia):
        super().__init__(marca, puertas)
        self.autonomia = autonomia
    
    def cargar_bateria(self):
        return f"Cargando batería con {self.autonomia} km de autonomía"

# Uso
tesla = CocheElectrico("Tesla", 4, 500)
print(tesla.mover())          # Heredado de Vehiculo
print(tesla.abrir_puertas())  # Heredado de Coche
print(tesla.cargar_bateria()) # Propio de CocheElectrico
3. Herencia Múltiple
python
class Volador:
    def volar(self):
        return "Volando alto"

class Nadador:
    def nadar(self):
        return "Nadando rápido"

class Pato(Volador, Nadador):  # Herencia múltiple
    def hacer_sonido(self):
        return "¡Cuac!"

# Uso
pato = Pato()
print(pato.volar())       # De Volador
print(pato.nadar())       # De Nadador
print(pato.hacer_sonido()) # Propio
4. Método super()
python
class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    
    def presentarse(self):
        return f"Soy {self.nombre}, tengo {self.edad} años"

class Estudiante(Persona):
    def __init__(self, nombre, edad, carrera):
        super().__init__(nombre, edad)  # Llama al constructor del padre
        self.carrera = carrera
    
    def presentarse(self):
        base = super().presentarse()  # Llama al método del padre
        return f"{base} y estudio {self.carrera}"

# Uso
estudiante = Estudiante("Ana", 20, "Ingeniería")
print(estudiante.presentarse())
# Soy Ana, tengo 20 años y estudio Ingeniería