COLEGIO IMB-PC (SEDE NARANJO) PROGRAMACIÓN 1
INVESTIGACIÓN COMPLETA: TAREA 5 – ABSTRACCIÓN, OBJETOS Y PROYECTO INTEGRADOR
Alumno: Juan Diego Mendoza Carrillo Fecha: Septiembre de 2026
Índice 1. Abstracción e Interfaces ..................................................... 3 1.1 Principios de abstracción, herencia y polimorfismo ...................... 3 1.2 Uso de clases abstractas (ABC) e interfaces informales .................. 3 1.3 Métodos abstractos y su implementación obligatoria ...................... 4 1.4 Combinación de decoradores y clases base ................................ 4 1.5 Análisis de los principios I (Interface Segregation) y D (Dependency Inversion) ..... 4 2. Relaciones entre objetos y diseño modular .................................... 5 2.1 Agregación y composición en Python ...................................... 5 2.2 Modelado de relaciones con diagramas UML ................................ 5 2.3 Aplicación de los principios S (Single Responsibility) y O (Open/Closed) ..... 6 2.4 Diseño de sistemas OO pequeños (Biblioteca, Tienda o Usuarios) .......... 6 2.5 Revisión de coherencia y dependencia entre clases ....................... 6 3. Proyecto integrador orientado a objetos ...................................... 7 3.1 Diseño y desarrollo de un proyecto OO completo .......................... 7 3.2 Análisis de requerimientos y diagramas UML previos ...................... 7 3.3 Aplicación explícita de los principios S.O.L.I.D. ....................... 7 3.4 Evaluación de código: legibilidad, reutilización y cohesión ............. 8 3.5 Presentación y defensa técnica del proyecto ............................. 8
Introducción Este documento presenta una investigación exhaustiva y detallada sobre los conceptos avanzados de la Programación Orientada a Objetos (POO) en Python, abarcando desde la abstracción, interfaces y el modelado modular, hasta la aplicación práctica de los principios SOLID y el desarrollo de un proyecto integrador robusto para la Tarea 5 del curso de Programación 1.
1. Abstracción e Interfaces La abstracción es uno de los pilares fundamentales de la programación orientada a objetos. Permite modelar entidades del mundo real enfocándose en los aspectos relevantes y omitiendo detalles de implementación complejos o innecesarios.
1.1 Principios de abstracción, herencia y polimorfismo
Abstracción: Es el proceso mental y de diseño mediante el cual se aísla la información esencial de un objeto, exponiendo únicamente su interfaz pública (métodos y atributos relevantes) y ocultando los detalles internos de su funcionamiento. Herencia: Mecanismo por el cual una clase (subclase o clase derivada) hereda atributos y métodos de otra clase (clase base o superclase), promoviendo la reutilización de código y el establecimiento de jerarquías lógicas. Polimorfismo: Capacidad que tienen diferentes objetos de responder de manera distinta al mismo estímulo o mensaje (método con idéntico nombre), permitiendo escribir código genérico que opera sobre múltiples tipos de datos.
1.2 Uso de clases abstractas (ABC) e interfaces informales En Python, las clases abstractas se implementan a través del módulo integrado abc (Abstract Base Classes). Una clase abstracta no puede ser instanciada directamente y sirve como una plantilla o contrato para las subclases. from abc import ABC, abstractmethod class DispositivoConectable(ABC): @abstractmethod def conectar(self) -> None: pass @abstractmethod def desconectar(self) -> None: pass
Por otro lado, las interfaces informales en Python se basan en la filosofía de 'pato' (duck typing), donde una clase define métodos esperados sin heredar explícitamente de una clase base abstracta, confiando en que el objeto implemente dichos comportamientos.
1.3 Métodos abstractos y su implementación obligatoria Los métodos abstractos decorados con @abstractmethod obligan a cualquier clase hija no abstracta a proporcionar una implementación concreta de dichos métodos. Si una subclase omite la implementación de un método abstracto, Python lanzará un error de tipo (TypeError) al intentar instanciarla.
1.4 Combinación de decoradores y clases base Los decoradores en Python permiten modificar o mejorar dinámicamente el comportamiento de clases y métodos. Al combinarse con clases base abstractas, facilitan la implementación de patrones de diseño como Template Method, Property Wrappers o validaciones automáticas de tipos antes de la ejecución de los métodos de negocio.
1.5 Análisis de los principios I (Interface Segregation) y D (Dependency Inversion)
Principio de Segregación de Interfaces (ISP): Establece que ningún cliente debe ser forzado a depender de métodos que no utiliza. En lugar de crear interfaces monolíticas grandes, es preferible diseñar múltiples interfaces específicas y pequeñas para cada cliente. Principio de Inversión de Dependencias (DIP): Los módulos de alto nivel no deben depender de módulos de bajo nivel; ambos deben depender de abstracciones. Además, las abstracciones no deben depender de los detalles, sino los detalles de las abstracciones.
2. Relaciones entre objetos y diseño modular El diseño modular y el establecimiento correcto de relaciones entre clases determinan la mantenibilidad, escalabilidad y robustez de una aplicación orientada a objetos.
2.1 Agregación y composición en Python
Agregación: Representa una relación de tipo 'todo/parte' donde el ciclo de vida del objeto parte es independiente del objeto todo. Por ejemplo, un departamento contiene profesores, pero si el departamento desaparece, los profesores siguen existiendo. Composición: Es una forma más restrictiva de agregación donde el objeto parte no puede existir sin el objeto todo. Si el contenedor se destruye, sus componentes internos también son destruidos. Ejemplo: una factura y sus líneas de detalle.
2.2 Modelado de relaciones con diagramas UML El Lenguaje Unificado de Modelado (UML) es la herramienta estándar para visualizar sistemas orientados a objetos:
Asociación: Conexión estructural simple entre clases que colaboran (línea continua con flecha opcional). Agregación: Rombo vacío unido al contenedor (línea continua).
Composición: Rombo relleno de color negro unido al contenedor (línea continua).
2.3 Aplicación de los principios S (Single Responsibility) y O (Open/Closed)
Principio de Responsabilidad Única (SRP): Una clase debe tener una, y solo una, razón para cambiar. Cada clase debe encargarse de una única parte de la funcionalidad proporcionada por el software. Principio Abierto/Cerrado (OCP): Las entidades de software (clases, módulos, funciones) deben estar abiertas para su extensión, pero cerradas para su modificación. Esto se logra mediante el uso de polimorfismo y clases abstractas.
2.4 Diseño de sistemas OO pequeños (Biblioteca, Tienda o Usuarios) Nota de Diseño: Ejemplo Práctico de Diseño Modular: En un sistema de Biblioteca, se separan las responsabilidades en clases como 'Libro', 'Usuario', 'Prestamo' y 'RepositorioDePrestamos'. La clase 'Prestamo' maneja la composición con la fecha y las reglas de negocio, mientras que 'Usuario' mantiene una agregación de sus libros en posesión.
2.5 Revisión de coherencia y dependencia entre clases Es fundamental evaluar periódicamente el acoplamiento (grado de interdependencia entre módulos) y la cohesión (grado en que los elementos dentro de un módulo pertenecen juntos). Un buen diseño busca bajo acoplamiento y alta cohesión.
3. Proyecto integrador orientado a objetos La culminación de la materia se plasma en el desarrollo de un proyecto integrador que aplica de manera holística todos los conceptos estudiados a lo largo del curso.
3.1 Diseño y desarrollo de un proyecto OO completo El proyecto integra herencia múltiple o multinivel, encapsulamiento riguroso mediante propiedades (@property y _atributos_privados), y composición dinámica para modelar escenarios complejos del mundo real con una arquitectura limpia.
3.2 Análisis de requerimientos y diagramas UML previos Antes de escribir código, se realiza un levantamiento formal de requerimientos funcionales y no funcionales, plasmados en diagramas de clases UML que especifican visibilidades (+ público, privado, # protegido), tipos de datos y cardinalidades.
3.3 Aplicación explícita de los principios S.O.L.I.D. El proyecto demuestra el cumplimiento estricto de los cinco principios SOLID, garantizando que el software sea resiliente ante cambios futuros en los requerimientos del cliente o del negocio.
3.4 Evaluación de código: legibilidad, reutilización y cohesión
Legibilidad: Adhesión a las guías PEP 8 en Python, uso de nombres descriptivos, documentación con docstrings y tipado estático (type hints). Reutilización: Diseñar componentes modulares que puedan ser reutilizados en otros contextos sin modificaciones. Cohesión: Asegurar que cada clase y paquete cumpla una tarea bien definida y acotada.
3.5 Presentación y defensa técnica del proyecto La fase final comprende la demostración en vivo del funcionamiento del sistema, la explicación de las decisiones de diseño arquitectónico adoptadas y la justificación del cumplimiento de los estándares de calidad de código.