Herencia y Polimorfismo

 

1. Herencia

La herencia permite crear una clase nueva basada en otra. La clase hija hereda atributos y métodos de la clase padre.

class Persona:
    def __init__(self, nombre):
        self.nombre = nombre

    def saludar(self):
        return f"Hola, soy {self.nombre}"

class Alumno(Persona):
    pass

a = Alumno("Ana")
print(a.saludar())

La clase Alumno hereda el método saludar() sin necesidad de reescribirlo.

2. Añadir o extender funcionalidad

La clase hija puede añadir nuevos atributos o métodos.

class Alumno(Persona):
    def __init__(self, nombre, curso):
        super().__init__(nombre)   # Llama al constructor de Persona
        self.curso = curso

3. Sobrescritura de métodos (override)

La clase hija puede redefinir un método del padre.

class Profesor(Persona):
    def saludar(self):
        return f"Buenos días, soy el profesor {self.nombre}"

Polimorfismo

El polimorfismo permite que diferentes clases respondan de forma distinta al mismo método.

Ejemplo clásico:

class Persona:
    def rol(self):
        return "Soy una persona"

class Alumno(Persona):
    def rol(self):
        return "Soy un alumno"

class Profesor(Persona):
    def rol(self):
        return "Soy un profesor"

def presentar(obj):
    print(obj.rol())

presentar(Alumno())
presentar(Profesor())

Cada objeto ejecuta su propia versión del método rol().

Polimorfismo con colecciones

personas = [Alumno(), Profesor(), Persona()]

for p in personas:
    print(p.rol())

Cada objeto se comporta según su clase.

ACTIVIDAD PRÁCTICA: “Sistema de gestión del centro educativo”

Objetivo: que tus alumnos entiendan herencia, sobrescritura y polimorfismo en un caso real de FP.

Enunciado

Crea un sistema con estas clases:

Clase base: Persona

  • nombre

  • edad

  • método descripcion() → devuelve "Soy una persona llamada X"

Clase hija: Alumno

  • curso

  • sobrescribe descripcion() → "Soy el alumno X del curso Y"

Clase hija: Profesor

  • asignatura

  • sobrescribe descripcion() → "Soy el profesor X de la asignatura Y"

Clase hija: Administrador

  • departamento

  • sobrescribe descripcion() → "Soy el administrador X del departamento Y"

Después:

  1. Crea una lista con objetos de los tres tipos.

  2. Recorre la lista y muestra la descripción de cada uno (polimorfismo).

  3. Añade un método común saludar() en Persona y comprueba que todos lo heredan.

Solución propuesta

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def descripcion(self):
        return f"Soy una persona llamada {self.nombre}"

    def saludar(self):
        return f"Hola, soy {self.nombre}"


class Alumno(Persona):
    def __init__(self, nombre, edad, curso):
        super().__init__(nombre, edad)
        self.curso = curso

    def descripcion(self):
        return f"Soy el alumno {self.nombre} del curso {self.curso}"


class Profesor(Persona):
    def __init__(self, nombre, edad, asignatura):
        super().__init__(nombre, edad)
        self.asignatura = asignatura

    def descripcion(self):
        return f"Soy el profesor {self.nombre} de {self.asignatura}"


class Administrador(Persona):
    def __init__(self, nombre, edad, departamento):
        super().__init__(nombre, edad)
        self.departamento = departamento

    def descripcion(self):
        return f"Soy el administrador {self.nombre} del departamento {self.departamento}"


# Crear objetos
p1 = Alumno("Ana", 17, "1º DAM")
p2 = Profesor("Luis", 40, "Programación")
p3 = Administrador("Marta", 35, "Secretaría")

personas = [p1, p2, p3]

# Polimorfismo
for p in personas:
    print(p.descripcion())
    print(p.saludar())
    print()

Ejemplo de salida

Soy el alumno Ana del curso 1º DAM
Hola, soy Ana

Soy el profesor Luis de Programación
Hola, soy Luis

Soy el administrador Marta del departamento Secretaría
Hola, soy Marta