Programación Orientada a Objetos

# =====================================================
# Práctica Unidad 2 - Los 4 Pilares de la POO
# Asignatura: POO | UTH 2026-2
# Sistema de Gestión de Institución Educativa
# =====================================================

from abc import ABC, abstractmethod

# 'ABC' es la clase base de la que heredan nuestras clases abstractas
# 'abstractmethod' es un decorador que marca métodos que DEBEN implementarse

class Persona(ABC):
    """
    Clase ABSTRACTA que representa a cualquier persona de la institución.
    No se puede instanciar directamente — es solo una plantilla.
    """

    def __init__(self, nombre: str, edad: int, id_persona: str):
        """Constructor de Persona."""
        # Atributos PROTEGIDOS (un guión bajo = convención "no acceder directo")
        self._nombre     = nombre
        self._edad       = edad
        self._id_persona = id_persona

    # ── PROPERTIES (Encapsulamiento) ──
    @property
    def nombre(self):
        """Getter: devuelve el nombre (solo lectura)."""
        return self._nombre

    @property
    def edad(self):
        """Getter: devuelve la edad."""
        return self._edad

    @edad.setter
    def edad(self, nueva_edad: int):
        """Setter: valida y actualiza la edad."""
        if 0 < nueva_edad < 120:
            self._edad = nueva_edad
        else:
            print(f"❌ Edad inválida: {nueva_edad}")

    @property
    def id_persona(self):
        """Getter: devuelve el ID (solo lectura, sin setter)."""
        return self._id_persona

    # ── MÉTODO ABSTRACTO ──
    @abstractmethod
    def presentarse(self):
        """
        Método ABSTRACTO: cada subclase DEBE implementar este método.
        Si no lo implementa, Python lanza TypeError al instanciar.
        """
        pass

    def __str__(self):
        return f"Persona(ID:{self._id_persona}, Nombre:{self._nombre}, Edad:{self._edad})"

class Estudiante(Persona):
    """Clase que representa a un estudiante. Hereda de Persona."""

    MINIMO_APROBATORIO = 7.0  # Atributo de clase

    def __init__(self, nombre: str, edad: int, id_persona: str,
                 matricula: str, carrera: str, promedio: float = 0.0):
        """Constructor: llama al constructor padre y agrega atributos propios."""

        # super() llama al constructor de la clase padre (Persona)
        # Es obligatorio llamarlo para que los atributos del padre se inicialicen
        super().__init__(nombre, edad, id_persona)

        # Atributos PRIVADOS (doble guión bajo → name mangling)
        self.__matricula = matricula
        self.__carrera   = carrera
        self.__promedio  = promedio

    # ── PROPERTIES (Encapsulamiento) ──
    @property
    def matricula(self):
        return self.__matricula

    @property
    def carrera(self):
        return self.__carrera

    @property
    def promedio(self):
        return self.__promedio

    @promedio.setter
    def promedio(self, nuevo: float):
        """Setter con validación: solo acepta valores entre 0.0 y 10.0."""
        if 0.0 <= nuevo <= 10.0:
            self.__promedio = nuevo
        else:
            print(f"❌ Promedio inválido: {nuevo}. Debe estar entre 0.0 y 10.0")

    # ── MÉTODOS PROPIOS ──
    def esta_aprobado(self) -> bool:
        """Retorna True si el promedio es suficiente para aprobar."""
        return self.__promedio >= Estudiante.MINIMO_APROBATORIO

    # ── MÉTODO ABSTRACTO IMPLEMENTADO (override) ──
    def presentarse(self):
        """Implementación del método abstracto de Persona."""
        estado = "✅ Aprobado" if self.esta_aprobado() else "❌ Reprobado"
        print(f"🎓 Soy {self._nombre}, estudiante de {self.__carrera}.")
        print(f"   Matrícula: {self.__matricula} | Promedio: {self.__promedio:.1f} | {estado}")

    def __str__(self):
        return f"Estudiante({self._nombre}, {self.__matricula}, {self.__carrera}, {self.__promedio:.1f})"

class EstudianteBecario(Estudiante):
    """
    Estudiante con beca económica.
    Hereda de Estudiante (que a su vez hereda de Persona).
    Herencia de 3 niveles: Persona → Estudiante → EstudianteBecario
    """

    def __init__(self, nombre, edad, id_persona,
                 matricula, carrera, promedio, monto_beca: float):
        # Llama al constructor de Estudiante (que a su vez llama al de Persona)
        super().__init__(nombre, edad, id_persona, matricula, carrera, promedio)

        # Atributo propio de EstudianteBecario (privado)
        self.__monto_beca = monto_beca

    @property
    def monto_beca(self):
        return self.__monto_beca

    @monto_beca.setter
    def monto_beca(self, nuevo_monto: float):
        if nuevo_monto >= 0:
            self.__monto_beca = nuevo_monto
        else:
            print("❌ El monto de beca no puede ser negativo.")

    def presentarse(self):
        """Override de presentarse — incluye información de la beca."""
        # Llamamos al presentarse de Estudiante y añadimos la beca
        super().presentarse()
        print(f"   💰 Beca mensual: ${self.__monto_beca:,.2f}")

    def __str__(self):
        return f"EstudianteBecario({self.nombre}, Beca: ${self.__monto_beca:,.2f})"

class Profesor(Persona):
    """Clase que representa a un profesor. También hereda de Persona."""

    def __init__(self, nombre, edad, id_persona,
                 num_empleado: str, especialidad: str, salario: float):
        super().__init__(nombre, edad, id_persona)
        self.__num_empleado = num_empleado
        self.__especialidad = especialidad
        self.__salario      = salario

    @property
    def num_empleado(self):
        return self.__num_empleado

    @property
    def especialidad(self):
        return self.__especialidad

    @property
    def salario(self):
        return self.__salario

    @salario.setter
    def salario(self, nuevo_salario: float):
        if nuevo_salario > 0:
            self.__salario = nuevo_salario
        else:
            print("❌ El salario debe ser mayor a 0.")

    def dar_aumento(self, porcentaje: float):
        """Aumenta el salario en el porcentaje indicado."""
        if 0 < porcentaje <= 100:
            aumento = self.__salario * (porcentaje / 100)
            self.__salario += aumento
            print(f"✅ Aumento del {porcentaje}% aplicado. Nuevo salario: ${self.__salario:,.2f}")
        else:
            print("❌ El porcentaje debe estar entre 1 y 100.")

    # ── Implementación del método abstracto ──
    def presentarse(self):
        print(f"👨‍🏫 Soy el Prof. {self._nombre}, especialidad: {self.__especialidad}.")
        print(f"   Empleado #{self.__num_empleado} | Salario: ${self.__salario:,.2f}")

    def __str__(self):
        return f"Profesor({self._nombre}, {self.__especialidad}, ${self.__salario:,.2f})"

def hacer_presentacion(persona: Persona):
    """
    Función polimórfica: acepta cualquier Persona (o subclase).
    Llama a presentarse() → cada clase lo implementa diferente.
    """
    print("-" * 50)
    persona.presentarse()   # polimorfismo en acción
    print("-" * 50)

if __name__ == "__main__":

    print("\n🏫 SISTEMA UTH — GESTIÓN DE PERSONAS")
    print("=" * 55)

    # ── 1. HERENCIA y ABSTRACCIÓN: crear objetos de subclases ──
    # Nota: NO se puede hacer: persona = Persona("Ana", 20, "P001")
    # Porque Persona es abstracta. Probar esto te dará TypeError.

    est1 = Estudiante("Ana López", 20, "P001",
                        "DSM2024001", "DSM", 8.5)

    est2 = Estudiante("Carlos Mendoza", 22, "P002",
                        "DSM2024002", "DSM", 5.9)

    becario = EstudianteBecario("María García", 19, "P003",
                                    "DSM2024003", "DSM", 9.1, 3500.0)

    prof1 = Profesor("Ing. Bernardo Prado", 38, "E001",
                       "UTH-2001", "Programación Orientada a Objetos", 25000.0)

    # ── 2. POLIMORFISMO: misma función, comportamientos distintos ──
    print("\n🎤 PRESENTACIONES (Polimorfismo):")
    personas = [est1, est2, becario, prof1]
    for p in personas:
        hacer_presentacion(p)   # misma llamada, resultado diferente

    # ── 3. ENCAPSULAMIENTO: acceso controlado por properties ──
    print("\n🔒 DEMOSTRACIÓN DE ENCAPSULAMIENTO:")

    # Acceso correcto: usando el getter (property)
    print(f"Promedio de Ana (getter): {est1.promedio}")

    # Modificación correcta: usando el setter (con validación)
    print("Cambiando promedio de Carlos a 7.2...")
    est2.promedio = 7.2   # llama automáticamente al @promedio.setter
    print(f"Nuevo promedio: {est2.promedio}")

    # Intento de valor inválido — el setter lo rechaza
    print("Intentando poner promedio = 15 (inválido)...")
    est2.promedio = 15    # el setter impide esto

    # Aumento de salario al profesor
    print("\n💰 DANDO AUMENTO AL PROFESOR:")
    prof1.dar_aumento(10)   # 10% de aumento

    # ── 4. HERENCIA MULTINIVEL: EstudianteBecario tiene TODO ──
    print("\n🎓 DATOS DEL ESTUDIANTE BECARIO (herencia multinivel):")
    print(f"Nombre (de Persona):    {becario.nombre}")
    print(f"Matrícula (de Estudiante): {becario.matricula}")
    print(f"Beca (propio):          ${becario.monto_beca:,.2f}")
    print(f"¿Aprobada? (de Estudiante): {becario.esta_aprobado()}")

    # ── isinstance(): verificar tipo de objeto ──
    print("\n🔍 VERIFICACIÓN DE TIPOS (isinstance):")
    print(f"¿becario es Persona?           {isinstance(becario, Persona)}")
    print(f"¿becario es Estudiante?        {isinstance(becario, Estudiante)}")
    print(f"¿becario es EstudianteBecario? {isinstance(becario, EstudianteBecario)}")
    print(f"¿becario es Profesor?          {isinstance(becario, Profesor)}")