Los aspectos clave de la herencia incluyen:
Existen varios tipos de herencia, aunque no todos los lenguajes de programación admiten todos los tipos. Los principales tipos son:
Python admite todos estos tipos de herencia. Exploremos cada uno con ejemplos.
La herencia simple es la forma más básica de herencia, donde una clase hereda de una sola clase base.
class Animal:
def __init__(self, especie):
self.especie = especie
def hacer_sonido(self):
pass
class Perro(Animal):
def __init__(self, nombre):
super().__init__("Canino")
self.nombre = nombre
def hacer_sonido(self):
return "¡Guau!"
# Uso
perro = Perro("Buddy")
print(f"{perro.nombre} es un {perro.especie}") # Salida: Buddy es un Canino
print(perro.hacer_sonido()) # Salida: ¡Guau!
En este ejemplo:
Animal es la clase base con un método genérico hacer_sonido.Perro es derivado de Animal, heredando sus atributos y métodos.Perro sobrescribe el método hacer_sonido con su propia implementación.super().__init__() para llamar al inicializador de la clase base.La herencia múltiple permite que una clase herede de múltiples clases base. Algunos lenguajes no permiten este tipo de herencia.
class Volador:
def volar(self):
return "¡Puedo volar!"
class Nadador:
def nadar(self):
return "¡Puedo nadar!"
class Pato(Animal, Volador, Nadador):
def __init__(self, nombre):
Animal.__init__(self, "Ave")
self.nombre = nombre
def hacer_sonido(self):
return "¡Cuac!"
# Uso
pato = Pato("Donald")
print(f"{pato.nombre} es un {pato.especie}") # Salida: Donald es un Ave
print(pato.hacer_sonido()) # Salida: ¡Cuac!
print(pato.volar()) # Salida: ¡Puedo volar!
print(pato.nadar()) # Salida: ¡Puedo nadar!
Aquí, Pato hereda de Animal, Volador y Nadador, combinando atributos y métodos de las tres clases.
En la herencia multinivel, una clase derivada hereda de otra clase derivada.
class Mamifero(Animal):
def __init__(self, especie, es_de_sangre_caliente=True):
super().__init__(especie)
self.es_de_sangre_caliente = es_de_sangre_caliente
def dar_a_luz(self):
return "Dando a luz crías vivas"
class Gato(Mamifero):
def __init__(self, nombre):
super().__init__("Felino")
self.nombre = nombre
def hacer_sonido(self):
return "¡Miau!"
# Uso
gato = Gato("Bigotes")
print(f"{gato.nombre} es un {gato.especie}") # Salida: Bigotes es un Felino
print(gato.hacer_sonido()) # Salida: ¡Miau!
print(gato.dar_a_luz()) # Salida: Dando a luz crías vivas
print(f"¿Es de sangre caliente? {gato.es_de_sangre_caliente}") # Salida: ¿Es de sangre caliente? True
En este ejemplo, Gato hereda de Mamifero, que a su vez hereda de Animal, formando una cadena de herencia multinivel.
La herencia jerárquica implica múltiples clases derivadas heredando de una sola clase base.
class Ave(Animal):
def __init__(self, especie, puede_volar=True):
super().__init__(especie)
self.puede_volar = puede_volar
class Loro(Ave):
def __init__(self, nombre):
super().__init__("Psitácido", puede_volar=True)
self.nombre = nombre
def hacer_sonido(self):
return "¡Squawk!"
class Pinguino(Ave):
def __init__(self, nombre):
super().__init__("Esfenisciforme", puede_volar=False)
self.nombre = nombre
def hacer_sonido(self):
return "¡Honk!"
# Uso
loro = Loro("Polly")
pinguino = Pinguino("Pingu")
print(f"{loro.nombre} puede volar: {loro.puede_volar}") # Salida: Polly puede volar: True
print(f"{pinguino.nombre} puede volar: {pinguino.puede_volar}") # Salida: Pingu puede volar: False
Aquí, tanto Loro como Pinguino heredan de Ave, lo que demuestra la herencia jerárquica.
La herencia híbrida es una combinación de múltiples tipos de herencia. Veamos un ejemplo más complejo para ilustrar esto:
class Terrestre:
def caminar(self):
return "Caminando en tierra"
class Acuatico:
def nadar(self):
return "Nadando en el agua"
class Anfibio(Animal, Terrestre, Acuatico):
def __init__(self, especie):
Animal.__init__(self, especie)
def adaptarse(self):
return "Puede sobrevivir tanto en tierra como en agua"
class Rana(Anfibio):
def __init__(self, nombre):
super().__init__("Anuro")
self.nombre = nombre
def hacer_sonido(self):
return "¡Croac!"
# Uso
rana = Rana("Kermit")
print(f"{rana.nombre} es un {rana.especie}") # Salida: Kermit es un Anuro
print(rana.hacer_sonido()) # Salida: ¡Croac!
print(rana.caminar()) # Salida: Caminando en tierra
print(rana.nadar()) # Salida: Nadando en el agua
print(rana.adaptarse()) # Salida: Puede sobrevivir tanto en tierra como en agua
Este ejemplo demuestra la herencia híbrida:
Rana hereda de AnfibioAnfibio hereda de Animal, Terrestre, y AcuaticoLa herencia ofrece varias ventajas. Sin embargo, también hay consideraciones importantes:
Para abordar estas consideraciones:
Visualicemos las relaciones de herencia que hemos discutido utilizando un diagrama de clases UML:
classDiagram
Animal <|-- Mamífero
Animal <|-- Ave
Mamífero <|-- Perro
Mamífero <|-- Gato
Ave <|-- Loro
Ave <|-- Pingüino
Animal <|-- Anfibio
Terrestre <|-- Anfibio
Acuático <|-- Anfibio
Anfibio <|-- Rana
class Animal {
+especie: str
+hacer_sonido()
}
class Mamífero {
+es_de_sangre_caliente: bool
+dar_a_luz()
}
class Ave {
+puede_volar: bool
}
class Anfibio {
+adaptarse()
}
class Terrestre {
+caminar()
}
class Acuático {
+nadar()
}
Este diagrama ilustra las relaciones de herencia entre las clases que hemos discutido, mostrando tanto la herencia simple como la múltiple.
¡Gracias por llegar hasta acá! Espero que este recorrido por el universo de la programación haya sido tan apasionante para vos como lo fue para mí escribirlo.
Nos encantaría escuchar lo que pensás, así que no te quedes callado/a, dejá tus comentarios, sugerencias y todas esas ideas copadas que seguro se te ocurrieron.
Y para ir más allá de estas líneas, date una vuelta por los ejemplos prácticos que preparamos para vos. Vas a encontrar todo el código y los proyectos en nuestro repositorio de GitHub learn-software-engineering/examples.
¡Gracias por ser parte de esta comunidad de aprendizaje. Seguí programando y explorando nuevos territorios en este fascinante mundo de la computación!