Programación Orientada a Objetos con Java para Ingeniería de Sistemas

1. Introducción a la Programación Orientada a Objetos (POO)

• Definición y concepto básico: Se abordará qué es la POO, sus características fundamentales y cómo se diferencia de otros paradigmas de programación.
• Importancia en ingeniería de sistemas: Relevancia de la POO en el desarrollo de software moderno y su impacto en la ingeniería de sistemas.

2. Historia y evolución de la Programación Orientada a Objetos

• Orígenes y primeros lenguajes: Desde Simula y Smalltalk hasta la adopción en lenguajes modernos.
• Hitos y contribuciones clave: Evolución de conceptos fundamentales y su influencia en la ingeniería de software.
• Impacto en el desarrollo de software: Avances en eficiencia, mantenimiento y reutilización gracias a la POO.

3. Conceptos fundamentales de la POO

• Clases y objetos: Definición, relación entre ellos, y ejemplos concretos en Java.
• Atributos y métodos: Qué son, tipos, y cómo se utilizan para modelar características y comportamientos.
• Encapsulamiento: Protección de datos y acceso controlado a través de modificadores.
• Abstracción: Modelado de entidades relevantes y ocultamiento de detalles no esenciales.
• Herencia y Polimorfismo (introducción básica): Conceptos iniciales para anticipar unidades futuras.

4. Comparación entre Programación Orientada a Objetos y Programación Estructurada

• Características de la programación estructurada: Procedimientos, modularidad y control de flujo.
• Limitaciones de la programación estructurada: Dificultades en el manejo de sistemas complejos y mantenimiento.
• Ventajas de la POO: Reutilización, modularidad, escalabilidad y alineación con modelos del mundo real.
• Relevancia práctica en ingeniería de sistemas: Casos de uso y ejemplos comparativos.

5. Aplicación de la POO a problemas simples de ingeniería

• Identificación de problemas susceptibles de modelado orientado a objetos: Análisis de ejemplos simples.
• Justificación del uso de la POO: Beneficios y adecuación del paradigma para los problemas planteados.
• Ejemplos prácticos: Modelado básico con clases, objetos, atributos y métodos en Java.

Actividad 1: Mapas conceptuales sobre la historia y evolución de la POO

Objetivo: Facilitar la comprensión de la evolución histórica de la POO y su impacto en la ingeniería de software.

Descripción:

• Se divide a los estudiantes en grupos pequeños (3-4 integrantes).
• Cada grupo investiga un periodo específico de la historia de la POO (por ejemplo, orígenes, lenguajes clave, hitos importantes).
• Con la información recopilada, elaboran un mapa conceptual que ilustre la evolución y sus contribuciones.
• Presentan su mapa a la clase y se discuten las conexiones entre los periodos.

Organización: Grupos

Producto esperado: Mapas conceptuales digitales o en papel y exposición oral breve.

Duración estimada: 90 minutos

Actividad 2: Identificación y definición de clases, objetos, atributos y métodos

Objetivo: Explicar los conceptos fundamentales de la POO con ejemplos claros y precisos.

Descripción:

• Se presenta un problema simple de ingeniería (por ejemplo, modelar un sistema de gestión de bibliotecas).
• Individualmente, los estudiantes identifican qué entidades pueden ser clases y cuáles serían sus atributos y métodos.
• Luego, en parejas, comparan sus resultados y discuten sus decisiones.
• Finalmente, se realiza una puesta en común con toda la clase para consolidar los conceptos y corregir posibles errores.

Organización: Individual y en parejas

Producto esperado: Listado de clases, atributos y métodos definidos para el problema dado.

Duración estimada: 60 minutos

Actividad 3: Debate comparativo entre POO y programación estructurada

Objetivo: Comparar las ventajas de la POO frente a la programación estructurada y su relevancia en ingeniería de sistemas.

Descripción:

• Se forman dos equipos: uno defiende la programación estructurada y otro la programacion orientada a objetos.
• Cada equipo prepara argumentos basados en ventajas, limitaciones y aplicaciones prácticas.
• Se realiza un debate moderado donde cada equipo expone sus puntos y responde preguntas del oponente y del docente.
• Al final, se realiza una reflexión conjunta resaltando las fortalezas y situaciones adecuadas para cada paradigma.

Organización: Grupos

Producto esperado: Argumentos escritos y participación activa en el debate.

Duración estimada: 75 minutos

Actividad 4: Modelado básico en Java de un problema simple de ingeniería

Objetivo: Identificar y analizar problemas simples que puedan ser abordados con POO, justificando la aplicabilidad de sus principios.

Descripción:

• Se presenta un problema sencillo, por ejemplo, un sistema para gestión de dispositivos electrónicos.
• Individualmente, los estudiantes diseñan clases con atributos y métodos básicos que modelen el problema.
• Implementan un código Java básico que cree objetos y utilice sus métodos para simular acciones del sistema.
• Se comparte el código y se realiza una revisión en clase, discutiendo la aplicabilidad del paradigma.

Organización: Individual

Producto esperado: Código Java funcional y breve reporte explicativo.

Duración estimada: 120 minutos

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre paradigmas de programación, familiaridad con términos básicos y experiencias previas con programación estructurada o POO.

Cómo se evalúa: Cuestionario corto con preguntas abiertas y de selección múltiple.

Instrumento sugerido: Prueba escrita o en línea con 10 preguntas breves.

Evaluación formativa

Qué se evalúa: Comprensión de conceptos fundamentales, capacidad para identificar elementos de POO, participación en actividades y razonamiento crítico sobre paradigmas.

Cómo se evalúa: Observación directa durante actividades, revisión de productos parciales (mapas conceptuales, listados, argumentos de debate) y retroalimentación continua.

Instrumento sugerido: Rúbricas para mapas conceptuales, listados de clases y métodos, y participación en debate; listas de cotejo para actividades prácticas.

Evaluación sumativa

Qué se evalúa: Capacidad para explicar conceptos básicos con ejemplos, comparar paradigmas, describir la evolución histórica y aplicar la POO a problemas simples.

Cómo se evalúa: Examen escrito teórico-práctico y entrega de un pequeño proyecto de modelado en Java.

Instrumento sugerido: Prueba escrita con preguntas teóricas y ejercicios prácticos; rúbrica para evaluación del proyecto de modelado.

La unidad "Introducción a la Programación Orientada a Objetos" se sugiere impartir en 2 semanas, con un total aproximado de 10 horas distribuidas de la siguiente manera:

• 2 horas para la presentación teórica de historia, evolución y conceptos fundamentales.
• 3 horas para actividades prácticas y discusión sobre clases, objetos, atributos y métodos.
• 2 horas para comparación con programación estructurada y debate.
• 3 horas para modelado y programación básica en Java, incluyendo revisión y retroalimentación.

1. Introducción y configuración del entorno Java

• Descripción general del lenguaje Java y su relevancia en la programación orientada a objetos.
• Instalación del JDK (Java Development Kit): descarga, instalación y configuración de variables de entorno.
• Selección e instalación de un IDE adecuado (Eclipse, IntelliJ IDEA o NetBeans): características y configuración inicial.
• Primer proyecto Java en el IDE: creación, estructura de archivos y ejecución básica.

2. Características principales del lenguaje Java y estructura básica

• Características del lenguaje: portabilidad, tipado estático, orientación a objetos, manejo de memoria y seguridad.
• Estructura básica de un programa Java: paquetes, clases, métodos, el método main.
• Convenciones de nomenclatura y estilo en Java.
• Elementos fundamentales para POO: clases, objetos, atributos y métodos.

3. Sintaxis básica en Java

• Declaración y tipos de datos primitivos: int, double, char, boolean, etc.
• Declaración de variables y constantes (final).
• Operadores básicos: aritméticos, relacionales, lógicos, asignación y unarios.
• Estructuras de control: condicionales (if, else, switch) y bucles (for, while, do-while).
• Buenas prácticas para la escritura de código legible y mantenible.

4. Conceptos básicos de Programación Orientada a Objetos en Java

• Definición de clases y creación de objetos.
• Atributos y métodos: definición, encapsulación básica (modificadores de acceso).
• Constructores: propósito y sintaxis.
• Uso de la palabra clave this.
• Invocación de métodos y acceso a atributos desde objetos.

5. Depuración y ejecución de programas Java básicos

• Identificación y corrección de errores sintácticos comunes.
• Introducción a la depuración en el IDE: puntos de interrupción, inspección de variables y paso a paso.
• Manejo básico de excepciones: try-catch para mejorar la robustez del código.
• Ejecutar programas Java desde el IDE y línea de comandos.

Instalación y configuración del entorno Java

Objetivo: Instalar y configurar correctamente el entorno de desarrollo Java (JDK y un IDE).

Descripción:

• Descargar el JDK desde la página oficial de Oracle o OpenJDK.
• Instalar el JDK siguiendo las instrucciones del sistema operativo.
• Configurar las variables de entorno necesarias (JAVA_HOME y PATH).
• Seleccionar e instalar un IDE (Eclipse, IntelliJ IDEA o NetBeans).
• Crear un proyecto Java básico y ejecutar un programa "Hola Mundo".

Organización: Individual

Producto esperado: Capturas de pantalla del entorno configurado, y código fuente del programa "Hola Mundo" funcionando.

Duración estimada: 2 horas

Explorando la estructura básica de un programa Java

Objetivo: Explicar las características principales del lenguaje Java y su estructura básica.

Descripción:

• Analizar en grupo un programa Java sencillo prestando atención a paquetes, clases, métodos y el método main.
• Identificar y comentar cada parte del código para explicar su función.
• Crear un diagrama básico que represente la estructura del programa.

Organización: Parejas

Producto esperado: Documento con el código comentado y el diagrama de estructura.

Duración estimada: 1.5 horas

Programando con sintaxis básica en Java

Objetivo: Escribir programas sencillos en Java utilizando sintaxis básica, variables, operadores y estructuras de control.

Descripción:

• Crear un programa que declare variables de distintos tipos y realice operaciones aritméticas.
• Implementar estructuras condicionales para evaluar condiciones simples.
• Utilizar bucles para repetir procesos con diferentes condiciones.
• Aplicar buenas prácticas en la escritura del código.

Organización: Individual

Producto esperado: Código fuente de programas con comentarios explicativos y resultados de ejecución.

Duración estimada: 3 horas

Creación y uso básico de clases y objetos en Java

Objetivo: Aplicar conceptos básicos de POO en Java mediante la creación de clases y objetos funcionales.

Descripción:

• Definir una clase con atributos, métodos y un constructor.
• Crear objetos de esa clase y utilizar sus métodos para modificar y mostrar información.
• Ejecutar el programa y verificar el comportamiento esperado.

Organización: Parejas

Producto esperado: Código fuente con comentarios y evidencia de ejecución correcta.

Duración estimada: 2.5 horas

Depuración y corrección de errores en programas Java

Objetivo: Depurar y ejecutar programas Java básicos, identificando y corrigiendo errores.

Descripción:

• Proporcionar a los estudiantes un programa Java con errores sintácticos y lógicos intencionales.
• Utilizar herramientas de depuración del IDE para localizar y corregir errores.
• Documentar el proceso de depuración y explicar las correcciones realizadas.

Organización: Individual

Producto esperado: Informe de errores encontrados y código corregido con evidencia de ejecución exitosa.

Duración estimada: 2 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre programación básica y manejo de entornos de desarrollo.

Cómodo se evalúa: Cuestionario de opción múltiple y preguntas abiertas breves.

Instrumento sugerido: Test en plataforma virtual o papel, con preguntas sobre conceptos básicos de programación y configuración de entornos.

Evaluación formativa

Qué se evalúa: Progreso en la instalación y configuración del entorno, comprensión de la estructura de programas Java, aplicación de sintaxis básica y creación de clases y objetos.

Cómodo se evalúa: Revisión continua de actividades prácticas, retroalimentación individual o grupal, participación en discusiones y entrega de productos parciales.

Instrumento sugerido: Listas de cotejo para actividades prácticas, rúbricas para evaluar calidad y corrección de código, observaciones del docente durante las sesiones.

Evaluación sumativa

Qué se evalúa: Competencia para instalar y configurar el entorno Java, explicar características y estructura del lenguaje, escribir programas básicos, aplicar conceptos de POO y depurar código.

Cómodo se evalúa: Proyecto integrador que incluya la creación de un programa Java sencillo orientado a objetos, con correcta sintaxis, ejecución y documentación del proceso de depuración.

Instrumento sugerido: Rúbrica detallada que valore instalación/configuración, diseño de código, implementación, corrección de errores y presentación del proyecto.

La unidad "Fundamentos de Java para POO" se recomienda impartir en un total de 11 horas distribuidas en 5 sesiones de aproximadamente 2 a 2.5 horas cada una. La distribución sugerida es:

• Sesión 1 (2 horas): Instalación y configuración del entorno Java.
• Sesión 2 (2 horas): Características del lenguaje y estructura básica del programa.
• Sesión 3 (3 horas): Sintaxis básica en Java (variables, operadores, estructuras de control).
• Sesión 4 (2.5 horas): Conceptos básicos de POO: clases y objetos.
• Sesión 5 (1.5 horas): Depuración y ejecución de programas Java básicos.

Este tiempo incluye actividades prácticas en clase y espacio para retroalimentación formativa.

1. Introducción a las Clases y Objetos en Java

• Concepto de programación orientada a objetos (POO) y su relevancia en Java.
• Definición de clase: estructura y componentes básicos.
• Definición de objeto: instancia de una clase, concepto y representación en memoria.
• Relación entre clase y objeto: modelo y ejemplar.

2. Estructura básica de una clase en Java

• Atributos: definición, tipos de datos, inicialización y convenciones de nombrado.
• Métodos: definición, sintaxis, parámetros, valor de retorno y sobrecarga.
• Ejemplo práctico de una clase simple con atributos y métodos.

3. Constructores en Java

• Definición y propósito de los constructores.
• Constructor por defecto y constructores parametrizados.
• Sintaxis para definir constructores en una clase.
• Buenas prácticas en la implementación de constructores.

4. Creación e instanciación de objetos

• Uso de la palabra clave new para instanciar objetos.
• Asignación de objetos a variables de referencia.
• Acceso a atributos y métodos mediante objetos.
• Ejemplos prácticos de instanciación y manipulación.

5. Ciclo de vida de un objeto en Java

• Creación, uso y destrucción de objetos.
• Alcance y tiempo de vida de variables y objetos.
• Garbage Collector: concepto y funcionamiento básico.
• Ejemplos que ilustran el ciclo de vida en código.

6. Modificadores de acceso y encapsulamiento

• Concepto de encapsulamiento y su importancia en POO.
• Modificadores de acceso: public, private, protected y paquete por defecto.
• Declaración de atributos y métodos con modificadores de acceso.
• Implementación de getters y setters para proteger y controlar acceso a atributos.
• Buenas prácticas para garantizar la integridad de datos.

7. Análisis y corrección de errores comunes en clases y objetos

• Errores sintácticos comunes en definición de clases y objetos.
• Errores lógicos: mal uso de atributos, métodos y constructores.
• Problemas con el acceso a atributos y métodos debido a modificadores de acceso.
• Prácticas para depurar y mejorar código orientado a objetos en Java.
• Ejercicios de identificación y corrección de errores en fragmentos de código.

Actividad 1: Análisis y explicación de la estructura de una clase Java

Objetivo: Definir y explicar la estructura básica de una clase y un objeto en Java, incluyendo atributos y métodos.

Descripción:

• Se proporciona a los estudiantes un código fuente de una clase Java simple con atributos y métodos.
• Los estudiantes deben identificar y describir cada componente: atributos, métodos, nombre de la clase.
• En grupos pequeños, discuten la función de cada parte y cómo se relaciona con el concepto de objeto.
• Cada grupo presenta una explicación clara y precisa al resto de la clase.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Informe escrito breve y presentación oral explicativa.

Duración estimada: 1 hora

Actividad 2: Creación de una clase con constructores y métodos

Objetivo: Crear clases con constructores adecuados y métodos en Java aplicando sintaxis y buenas prácticas.

Descripción:

• Los estudiantes diseñan una clase que represente un objeto real (por ejemplo, "Coche", "Libro" o "CuentaBancaria").
• Definen atributos relevantes y al menos dos métodos que operen sobre esos atributos.
• Implementan un constructor por defecto y un constructor parametrizado.
• Comparten el código con el instructor para revisión y retroalimentación.

Organización: Individual

Producto esperado: Código fuente de la clase Java correctamente compilado y documentado.

Duración estimada: 2 horas

Actividad 3: Instanciación y manipulación de objetos en un programa Java

Objetivo: Instanciar objetos y manipular sus atributos y métodos demostrando comprensión del ciclo de vida del objeto.

Descripción:

• Se entrega a los estudiantes la clase creada en la actividad anterior.
• Los estudiantes escriben un programa Java que cree múltiples objetos de la clase, modifique atributos mediante métodos y muestre resultados.
• Se analiza el ciclo de vida de cada objeto creado en el programa.

Organización: Individual

Producto esperado: Programa Java funcional con salida demostrativa.

Duración estimada: 2 horas

Actividad 4: Taller de detección y corrección de errores en código orientado a objetos

Objetivo: Analizar y corregir errores comunes en definición y uso de clases y objetos, mejorando la calidad del código.

Descripción:

• Se entregan fragmentos de código con errores sintácticos y lógicos relacionados con clases, objetos, constructores y encapsulamiento.
• Por parejas, los estudiantes identifican y corrigen los errores, justificando sus correcciones.
• Se discuten las soluciones en plenaria para consolidar aprendizajes.

Organización: Parejas

Producto esperado: Código corregido y reporte de errores identificados con explicación.

Duración estimada: 1.5 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de programación orientada a objetos y familiaridad con sintaxis Java.

Cómo se evalúa: Cuestionario de preguntas abiertas y de opción múltiple sobre conceptos de clases, objetos, atributos y métodos.

Instrumento sugerido: Test en línea o papel con 10 preguntas cortas.

Evaluación Formativa

Qué se evalúa: Aplicación práctica de conceptos: definición de clases, uso de constructores, instanciación de objetos y encapsulamiento.

Cómo se evalúa: Revisión de código entregado en actividades 2 y 3 con retroalimentación continua.

Instrumento sugerido: Rubrica de evaluación de código (estructura, sintaxis, buenas prácticas, funcionalidad).

Evaluación Sumativa

Qué se evalúa: Dominio integral de la unidad incluyendo definición, creación, manipulación, análisis y corrección de clases y objetos en Java.

Cómo se evalúa: Examen práctico donde el estudiante debe desarrollar una clase con atributos, métodos y constructores, instanciar objetos, y realizar modificaciones con encapsulamiento correcto. Además, corregir un fragmento de código con errores.

Instrumento sugerido: Prueba práctica escrita y ejecución de código en ambiente Java.

La unidad "Clases y Objetos" se sugiere impartir en 2 semanas, distribuyendo aproximadamente 12 horas totales. Se recomienda:

• Semana 1 (6 horas): Introducción, estructura de clases, constructores, y primeras prácticas de creación de clases (actividades 1 y 2).
• Semana 2 (6 horas): Instanciación de objetos y manipulación, ciclo de vida, encapsulamiento, análisis y corrección de errores (actividades 3 y 4), además de evaluación formativa y sumativa.

1. Introducción al Encapsulamiento

• Definición de encapsulamiento en programación orientada a objetos.
• Importancia del encapsulamiento para la protección de datos y mantenimiento del código.
• Relación entre encapsulamiento, seguridad y cohesión en clases.

2. Modificadores de Acceso en Java

• Descripción general de los modificadores de acceso.
• Modificador private: significado y uso para atributos y métodos.
• Modificador protected: ámbito de acceso y ejemplos.
• Modificador public: acceso global y consideraciones.
• Acceso por defecto (paquete): comportamiento y limitaciones.
• Comparación y mejores prácticas para elegir modificadores adecuados.

3. Implementación Práctica del Encapsulamiento con Getters y Setters

• Concepto y propósito de los métodos getters y setters.
• Convenciones de nomenclatura para getters y setters en Java.
• Ejemplos de código: creación de clases con atributos privados y métodos públicos de acceso.
• Validación de datos dentro de setters para proteger la integridad de los atributos.
• Uso de encapsulamiento para facilitar la mantenibilidad y evolución del software.

4. Evaluación y Refactorización de Código Existente

• Análisis de ejemplos de código con problemas de encapsulamiento y acceso.
• Identificación de violaciones a principios de encapsulamiento.
• Refactorización para mejorar la protección de datos utilizando modificadores y métodos de acceso.
• Discusión sobre cohesión y acoplamiento relacionados con la visibilidad de miembros de clase.
• Buenas prácticas para documentar y justificar decisiones de diseño relacionadas con accesibilidad.

Actividad 1: Debate y Análisis Conceptual sobre Encapsulamiento

Objetivo: Explicar los conceptos de encapsulamiento y modificadores de acceso en Java.

Descripción:

• El docente presenta un escenario donde la falta de encapsulamiento genera problemas de seguridad y mantenimiento.
• Los estudiantes, en grupos pequeños, discuten cómo el encapsulamiento puede resolver estos problemas.
• Cada grupo expone sus conclusiones sobre la importancia de los modificadores de acceso y el encapsulamiento.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Presentación breve o mapa conceptual sobre la función del encapsulamiento y modificadores en Java.

Duración estimada: 45 minutos

Actividad 2: Aplicación Práctica de Modificadores de Acceso

Objetivo: Aplicar modificadores de acceso adecuados en clases Java para controlar visibilidad.

Descripción:

• Se entrega un código Java inicial con atributos y métodos sin modificadores o con acceso inapropiado.
• Los estudiantes identifican qué modificadores aplicar según las especificaciones dadas.
• Implementan los cambios en el código y prueban que el acceso sea el esperado mediante la creación de objetos y accesos desde otras clases.

Organización: Individual o parejas

Producto esperado: Código Java corregido con modificadores de acceso adecuados y breve informe justificando las elecciones.

Duración estimada: 1 hora

Actividad 3: Diseño y Codificación de Clases con Encapsulamiento

Objetivo: Diseñar y codificar clases que implementen encapsulamiento mediante getters y setters.

Descripción:

• Los estudiantes diseñan una clase Java para un sistema que requiere protección de datos (ejemplo: clase Usuario con atributos sensibles).
• Implementan atributos privados con sus respectivos métodos getters y setters, incluyendo validaciones en setters.
• Realizan pruebas unitarias básicas para verificar el correcto funcionamiento del acceso y modificación de datos.

Organización: Individual

Producto esperado: Código completo de la clase con encapsulamiento efectivo y reporte de pruebas realizadas.

Duración estimada: 1.5 horas

Actividad 4: Refactorización de Código para Mejorar la Protección de Datos

Objetivo: Evaluar y refactorizar código Java para mejorar encapsulamiento y cohesión.

Descripción:

• Se proporciona un fragmento de código con atributos públicos y métodos inseguros.
• Los estudiantes identifican problemas de diseño relacionados con la visibilidad y la protección de datos.
• Implementan refactorizaciones aplicando modificadores de acceso, getters y setters, y mejoran la cohesión de la clase.
• Discuten los beneficios obtenidos tras la refactorización y posibles implicaciones para el mantenimiento.

Organización: Parejas o grupos pequeños

Producto esperado: Código refactorizado y reporte de evaluación antes y después de la intervención.

Duración estimada: 2 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre encapsulamiento y modificadores de acceso.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas abiertas breves.

Instrumento sugerido: Prueba escrita o plataforma digital tipo quiz al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Aplicación práctica de modificadores, diseño de getters/setters, y refactorización.

Cómo se evalúa: Revisión continua de actividades prácticas, retroalimentación en clase y entrega de informes breves.

Instrumento sugerido: Rubricas para código y reportes, observación directa y autoevaluación guiada.

Evaluación Sumativa

Qué se evalúa: Comprensión teórica y práctica integral del encapsulamiento y modificadores de acceso.

Cómo se evalúa: Proyecto final donde el estudiante debe diseñar, codificar y documentar una clase o conjunto de clases, aplicando correctamente encapsulamiento y modificadores, además de realizar una breve reflexión escrita sobre las decisiones tomadas.

Instrumento sugerido: Rubrica detallada para evaluación de proyecto y reflexión escrita.

La unidad "Encapsulamiento y Modificadores de Acceso" se recomienda impartir en un total de 6 horas distribuidas en dos semanas, con la siguiente distribución:

• Semana 1 (3 horas): Introducción al encapsulamiento, conceptos teóricos, análisis y discusión en grupo (Actividad 1), y explicación de modificadores de acceso, seguida de ejercicios prácticos iniciales (Actividad 2).
• Semana 2 (3 horas): Implementación de clases con encapsulamiento mediante getters y setters (Actividad 3), y sesión de refactorización y evaluación crítica de código (Actividad 4), concluyendo con retroalimentación y preparación para la evaluación sumativa.

1. Introducción a la Herencia en Java

• Concepto de herencia: definición y propósito en programación orientada a objetos.
• Terminología básica: superclase (clase base), subclase (clase derivada), herencia simple vs. herencia múltiple.
• Ventajas de la herencia: reutilización de código, extensibilidad y mantenimiento.
• Limitaciones en Java respecto a la herencia múltiple y alternativas (interfaces).

2. Herencia Simple en Java

• Sintaxis para declarar herencia con la palabra clave extends.
• Acceso a atributos y métodos heredados.
• Ejemplo práctico básico: creación de superclase y subclase.
• Sobreescritura de métodos y concepto de polimorfismo básico.
• Uso de la palabra clave super para acceder a atributos y métodos de la superclase.

3. Herencia Múltiple en Java

• Por qué Java no soporta herencia múltiple de clases.
• Uso de interfaces para simular herencia múltiple.
• Implementación de múltiples interfaces y combinación con herencia simple.
• Ejemplos prácticos de diseño con interfaces para reutilización de código.

4. Reutilización de Código con Herencia y la palabra clave super

• Invocación del constructor de la superclase usando super() para inicialización correcta.
• Llamada a métodos de la superclase desde la subclase con super.metodo().
• Ejemplos prácticos: implementación de jerarquías de clases para resolver problemas de ingeniería.
• Buenas prácticas para evitar duplicación de código y maximizar la reutilización.

5. Diseño de Diagramas UML para Relaciones de Herencia

• Fundamentos de diagramas de clases UML orientados a objetos.
• Representación gráfica de superclases y subclases.
• Identificación y modelado de relaciones de herencia en diagramas UML.
• Ejercicios prácticos de diseño UML para sistemas orientados a objetos con herencia.

6. Análisis y Modificación de Código Java para Optimizar la Reutilización

• Revisión de código Java existente con duplicación o mala organización.
• Refactorización usando herencia y super para mejorar reutilización.
• Evaluación del impacto en la mantenibilidad y calidad del software.
• Ejemplos de casos reales y discusión sobre beneficios y posibles riesgos de la herencia.

7. Evaluación del Impacto de la Herencia en la Calidad del Software

• Conceptos de mantenibilidad, calidad y eficiencia en software orientado a objetos.
• Análisis crítico de ejemplos que usan herencia para reutilización eficiente.
• Discusión sobre buenas y malas prácticas en la aplicación de herencia.
• Conclusiones sobre el uso adecuado de la herencia en proyectos de ingeniería de software.

Actividad 1: Identificación de Superclases y Subclases en Código Java

Objetivo: Explicar los conceptos de herencia simple y múltiple, identificando superclases y subclases en ejemplos prácticos.

Descripción:

• Se entrega a los estudiantes fragmentos de código Java con varias clases, algunas relacionadas por herencia.
• Los estudiantes deben analizar el código para identificar superclases, subclases y relaciones de herencia simple.
• En grupos pequeños, discutirán si existe o no herencia múltiple y cómo se implementa en Java mediante interfaces.
• Finalmente, cada grupo presenta un resumen de sus hallazgos y explicaciones al resto de la clase.

Organización: grupos de 3-4 estudiantes

Producto esperado: reporte escrito y presentación oral con identificación clara de superclases, subclases y uso de interfaces.

Duración estimada: 90 minutos

Actividad 2: Implementación de Clases con Herencia y Uso de super

Objetivo: Implementar clases que utilizan herencia para reutilizar código mediante la palabra clave super en programas Java que resuelvan problemas de ingeniería.

Descripción:

• Se propone un problema de ingeniería (por ejemplo, modelar vehículos con clases base y específicas).
• Los estudiantes diseñan y programan una superclase y al menos dos subclases que hereden de ella.
• Implementan constructores y métodos que utilicen la palabra clave super para reutilizar código.
• Prueban el programa para verificar que la herencia y la reutilización funcionan correctamente.

Organización: individual o parejas

Producto esperado: código Java funcional con herencia y uso correcto de super, acompañado de un breve informe explicativo.

Duración estimada: 2 horas

Actividad 3: Diseño de Diagramas UML para Herencia

Objetivo: Diseñar diagramas UML que representen relaciones de herencia entre clases para modelar sistemas orientados a objetos.

Descripción:

• Se proporciona una descripción textual de un sistema con varias clases y relaciones de herencia.
• Los estudiantes crean diagramas de clases UML que representen claramente las superclases y subclases.
• Se incluye la identificación de atributos y métodos relevantes para cada clase.
• Los estudiantes presentan sus diagramas y justifican el diseño realizado.

Organización: individual

Producto esperado: diagramas UML digitales o en papel con anotaciones claras y presentación.

Duración estimada: 90 minutos

Actividad 4: Refactorización de Código para Mejorar Reutilización con Herencia

Objetivo: Analizar y modificar código Java existente para optimizar la reutilización de métodos y atributos usando herencia y la palabra clave super.

Descripción:

• Se entrega un código Java con duplicación de código y mala organización.
• Los estudiantes identifican oportunidades para aplicar herencia y super para mejorar la estructura.
• Modifican el código para extraer superclases, mover métodos y atributos comunes y utilizar super cuando corresponda.
• Comparan antes y después, evaluando el impacto en mantenibilidad y calidad del software.

Organización: parejas

Producto esperado: código refactorizado con comentarios y análisis escrito del impacto de los cambios.

Duración estimada: 2 horas

Evaluación Diagnóstica

Qué se evalúa: conocimientos previos sobre programación orientada a objetos, herencia y conceptos básicos de clases en Java.

Cómo se evalúa: cuestionario breve con preguntas teóricas y ejercicios simples para identificar superclases y subclases.

Instrumento sugerido: cuestionario en línea o en papel con preguntas de opción múltiple y análisis de código.

Evaluación Formativa

Qué se evalúa: comprensión y aplicación práctica de la herencia, uso de super, diseño UML y refactorización de código.

Cómo se evalúa: revisión continua de actividades prácticas, retroalimentación en clases y foros, observación de presentaciones y entregas de código.

Instrumento sugerido: rúbricas para evaluación de código, diagramas UML y presentaciones; listas de cotejo para participación y análisis.

Evaluación Sumativa

Qué se evalúa: dominio integral de la herencia y reutilización de código, capacidad de diseño y análisis crítico de software orientado a objetos.

Cómo se evalúa: examen escrito y práctico donde se deben explicar conceptos, diseñar UML, programar una solución con herencia y refactorizar código dado.

Instrumento sugerido: examen con preguntas teóricas, ejercicios de diseño UML y programación Java, además de análisis de código para refactorización.

La unidad "Herencia y Reutilización de Código" está diseñada para ser impartida en un total de 10 horas distribuidas en 2 semanas, con la siguiente propuesta de tiempo:

• Semana 1 (5 horas): Introducción a la herencia, herencia simple y múltiple, y primeros ejercicios prácticos de identificación y diseño UML.
• Semana 2 (5 horas): Implementación práctica con herencia y uso de super, refactorización de código y evaluación del impacto en calidad y mantenibilidad.

Se recomienda distribuir sesiones teóricas y prácticas alternadamente para favorecer la comprensión y aplicación inmediata de los conceptos.

1. Introducción al Polimorfismo en Java

• Concepto de polimorfismo: definición y relevancia en programación orientada a objetos.
• Importancia del polimorfismo para la flexibilidad y extensibilidad del código.
• Visión general de tipos de polimorfismo: estático y dinámico.

2. Polimorfismo Estático (Sobrecarga)

• Definición y características del polimorfismo estático.
• Sobrecarga de métodos:
  • Concepto y sintaxis en Java.
  • Reglas para sobrecargar métodos (diferentes parámetros, tipos, cantidad).
  • Ejemplos prácticos de sobrecarga de métodos.
• Sobrecarga de operadores en Java:
  • Limitaciones en Java respecto a la sobrecarga de operadores.
  • Alternativas para simular comportamiento similar mediante métodos.
• Beneficios y aplicaciones prácticas de la sobrecarga.

3. Polimorfismo Dinámico (Sobrescritura)

• Definición y fundamentos del polimorfismo dinámico.
• Sobrescritura de métodos:
  • Concepto y reglas para sobrescribir métodos en Java.
  • Uso de la anotación @Override para mejorar claridad y seguridad.
  • Ejemplos prácticos con clases base y derivadas.
• Uso de referencias de clase base para invocar métodos sobrescritos.
• Ventajas del polimorfismo dinámico en diseño de software.

4. Implementación y Uso Práctico del Polimorfismo

• Diseño de programas que usan polimorfismo para mejorar extensión y mantenimiento:
  • Patrones de diseño que aprovechan polimorfismo.
  • Ejemplos de casos reales en ingeniería de software.
• Evaluación del impacto del polimorfismo en la calidad del código:
  • Mantenibilidad, reutilización y reducción de acoplamiento.
  • Comparación entre código con y sin polimorfismo.

5. Análisis de Casos de Uso en Ingeniería

• Identificación de escenarios donde polimorfismo y sobrecarga mejoran la estructura del sistema.
• Justificación técnica de la elección de polimorfismo y sobrecarga en problemas específicos.
• Discusión de ventajas y posibles limitaciones en contextos reales.

Actividad 1: Análisis y Ejemplificación del Polimorfismo Estático y Dinámico

Objetivo: Explicar los diferentes tipos de polimorfismo en Java, distinguiendo entre polimorfismo estático y dinámico mediante ejemplos prácticos.

Descripción:

• Se presenta un conjunto de fragmentos de código Java con sobrecarga y sobrescritura.
• Los estudiantes analizan el comportamiento de cada fragmento y clasifican el tipo de polimorfismo que demuestra.
• Discuten en grupo las diferencias y efectos en la ejecución del programa.
• Finalmente, cada estudiante escribe un ejemplo propio que ilustre ambos tipos de polimorfismo.

Organización: Individual y luego discusión en grupos pequeños.

Producto esperado: Documento con ejemplos comentados y clasificación del polimorfismo.

Duración estimada: 1.5 horas.

Actividad 2: Implementación de Sobrecarga de Métodos en Java

Objetivo: Implementar la sobrecarga de métodos en Java para aumentar la reutilización y flexibilidad del código.

Descripción:

• Los estudiantes reciben un problema sencillo, por ejemplo, una clase calculadora que debe realizar operaciones con diferentes tipos y cantidades de parámetros.
• Implementan varias versiones del método para sumar números enteros, decimales y arreglos, aplicando sobrecarga.
• Prueban los métodos en un programa principal, verificando la correcta ejecución según la firma del método llamado.
• Discuten las ventajas de esta técnica para mantener el código limpio y organizado.

Organización: Individual.

Producto esperado: Código fuente Java funcional con sobrecarga de métodos y evidencias de pruebas.

Duración estimada: 2 horas.

Actividad 3: Diseño de Programa con Polimorfismo Dinámico para Extensibilidad

Objetivo: Diseñar y desarrollar programas en Java que utilicen polimorfismo para facilitar la extensión y mantenimiento del software.

Descripción:

• Se propone un sistema de gestión de formas geométricas (círculo, rectángulo, triángulo).
• Los estudiantes crean una clase base abstracta Forma con un método calcularÁrea() sobrescrito en cada subclase.
• Implementan un programa que utiliza referencias de la clase base para almacenar diferentes objetos y calcular áreas polimórficamente.
• Evaluación grupal del diseño y discusión sobre cómo el polimorfismo facilita futuras extensiones (agregar nuevas formas).

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Código fuente Java completo y un informe breve sobre el diseño y ventajas obtenidas.

Duración estimada: 3 horas.

Actividad 4: Análisis de Casos de Uso Reales y Justificación Técnica

Objetivo: Analizar casos de uso donde el polimorfismo y la sobrecarga mejoran la estructura del sistema, justificando su elección en contextos de problemas de ingeniería.

Descripción:

• Se presentan varios escenarios de sistemas reales (por ejemplo, gestión de dispositivos, procesamiento de pagos, interfaces gráficas).
• Los estudiantes, en grupos, identifican oportunidades para aplicar polimorfismo y sobrecarga.
• Preparan una presentación donde explican cómo estas técnicas mejoran la solución propuesta, incluyendo posibles riesgos o limitaciones.
• Discusión general y retroalimentación del docente.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Presentación oral con diapositivas o documento escrito con análisis y justificación.

Duración estimada: 2 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre programación orientada a objetos, especialmente conceptos básicos de polimorfismo y sobrecarga.

Cómo se evalúa: Cuestionario corto con preguntas teóricas y prácticas para identificar nivel de comprensión inicial.

Instrumento sugerido: Test en línea o papel con preguntas de opción múltiple y de desarrollo breve.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión y aplicación de polimorfismo y sobrecarga durante las actividades prácticas.

Cómo se evalúa: Revisión continua de los códigos entregados, participación en discusiones y calidad de análisis en actividades grupales.

Instrumento sugerido: Rúbricas para código fuente, listas de cotejo para participación y análisis, feedback escrito y oral.

Evaluación Sumativa

Qué se evalúa: Capacidad para explicar, implementar, diseñar y analizar polimorfismo y sobrecarga en Java, según los objetivos de la unidad.

Cómo se evalúa: Proyecto final donde el estudiante debe presentar un programa completo que utilice polimorfismo estático y dinámico, acompañado de un informe que explique las decisiones de diseño y justifique el uso de estas técnicas.

Instrumento sugerido: Evaluación con rúbrica que valore aspectos técnicos, claridad, justificación y calidad del código y documento.

La unidad "Polimorfismo y Sobrecarga" tiene una duración sugerida de 2 semanas, con un estimado total de 10 horas distribuidas de la siguiente forma:

• 4 horas para la exposición teórica y discusión inicial de conceptos.
• 2 horas para la realización de actividades individuales (Análisis de polimorfismo y sobrecarga).
• 3 horas para trabajos en grupo, diseño y desarrollo de programas con polimorfismo dinámico y análisis de casos reales.
• 1 hora para evaluación diagnóstica y sumativa, retroalimentación y cierre de la unidad.

La distribución puede adaptarse según la dinámica del curso y disponibilidad horaria, asegurando la oportunidad para la práctica y reflexión sobre los contenidos.

1. Introducción a la Abstracción en Programación Orientada a Objetos

• Definición y propósito de la abstracción
• Relación entre abstracción y encapsulamiento
• Ejemplos conceptuales de abstracción en sistemas reales
• Abstracción en Java: clases y métodos abstractos

2. Clases Abstractas en Java

• Definición y características de las clases abstractas
• Declaración de clases abstractas en Java
• Métodos abstractos: definición, propósito y sintaxis
• Restricciones y reglas para clases y métodos abstractos
• Ejemplos prácticos de clases abstractas en Java

3. Diseño de Clases Abstractas y Métodos Abstractos con UML

• Conceptos básicos de UML para modelado de clases
• Representación de clases abstractas en diagramas UML
• Notación de métodos abstractos y relaciones de herencia
• Diseño de modelos UML para sistemas con abstracción
• Casos prácticos: modelado UML de jerarquías con clases abstractas

4. Implementación Práctica de Clases Abstractas en Java

• Creación de clases abstractas y métodos abstractos en código Java
• Herencia y especialización: implementación de subclases concretas
• Invocación de métodos abstractos y polimorfismo
• Reutilización de código mediante clases abstractas
• Ejercicios de codificación con ejemplos reales

5. Comparación entre Clases Abstractas e Interfaces

• Definición y características de interfaces en Java
• Diferencias clave entre clases abstractas e interfaces
• Cuándo usar una clase abstracta o una interfaz
• Ejemplos y casos de uso típicos en ingeniería de sistemas
• Buenas prácticas para la selección de abstracción

6. Evaluación y Mejora de la Aplicación de Clases Abstractas en Proyectos

• Identificación de oportunidades para uso de clases abstractas en código existente
• Análisis de mantenibilidad y estructura del código con clases abstractas
• Patrones de diseño relacionados con clases abstractas
• Recomendaciones para refactorización y optimización
• Ejercicio de revisión crítica y propuesta de mejora en ejemplos de proyectos

Actividad 1: Discusión y análisis conceptual sobre abstracción

Objetivo: Identificar y explicar los conceptos de abstracción y clases abstractas en Java.

Descripción:

• Se presenta un conjunto de ejemplos cotidianos y de sistemas informáticos donde se aplica la abstracción.
• Los estudiantes, en grupos pequeños, discuten y extraen las características comunes de la abstracción.
• Cada grupo redacta una definición técnica de abstracción y clases abstractas en Java, utilizando terminología adecuada.
• Los grupos exponen sus definiciones y se realiza una síntesis grupal con el docente.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Documento breve con definición técnica y presentación oral.

Duración estimada: 1 hora y 30 minutos.

Actividad 2: Diseño UML de clases abstractas para un sistema de gestión

Objetivo: Diseñar clases abstractas y métodos abstractos con diagramas UML que representen comportamientos generales.

Descripción:

• Se plantea un caso de estudio: sistema de gestión de vehículos (con jerarquías como Vehículo, Automóvil, Motocicleta).
• Los estudiantes diseñan el diagrama UML, identificando clases abstractas y métodos abstractos.
• Se debe representar la herencia, métodos abstractos y atributos generales.
• Se revisan y discuten los diseños en clase, enfatizando la correcta notación UML y diseño conceptual.

Organización: Parejas o grupos de 3 estudiantes.

Producto esperado: Diagrama UML digital o dibujado a mano con anotaciones.

Duración estimada: 2 horas.

Actividad 3: Implementación práctica de clases abstractas y métodos abstractos en Java

Objetivo: Implementar clases abstractas y métodos abstractos para desarrollar aplicaciones que requieran especialización y reutilización de código.

Descripción:

• Proporcionar un conjunto base de clases abstractas relacionadas con un problema (ejemplo: sistema bancario con Cuenta como clase abstracta).
• Los estudiantes implementan las clases abstractas y crean subclases concretas (CuentaAhorros, CuentaCorriente), completando métodos abstractos.
• Se realizan pruebas de funcionamiento y se analiza el código para detectar reutilización y especialización.
• Se documenta el código con comentarios claros y se entrega el proyecto.

Organización: Individual o parejas.

Producto esperado: Código fuente Java funcional con clases abstractas y subclases.

Duración estimada: 3 horas.

Actividad 4: Debate y análisis crítico sobre clases abstractas vs interfaces

Objetivo: Analizar y diferenciar entre clases abstractas e interfaces, seleccionando la opción adecuada para modelar soluciones específicas.

Descripción:

• El docente presenta características, ventajas y limitaciones de clases abstractas e interfaces.
• Se asignan casos prácticos para que los estudiantes decidan cuál usar y justifiquen su elección.
• En grupos, discuten y preparan argumentos basados en el análisis técnico.
• Se realiza un debate en clase donde cada grupo expone y defiende su elección.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Documento con análisis de casos y presentación argumentativa.

Duración estimada: 1 hora y 30 minutos.

Actividad 5: Revisión y mejora de un proyecto con clases abstractas

Objetivo: Evaluar la correcta aplicación de clases abstractas en un proyecto de software e identificar mejoras en estructura y mantenibilidad.

Descripción:

• Se entrega a los estudiantes un proyecto de código Java con diseño parcial de clases abstractas.
• Los estudiantes analizan el código, detectando errores conceptuales o posibilidades de refactorización.
• Proponen mejoras en la estructura, documentan las recomendaciones y realizan una pequeña refactorización.
• Se comparten los resultados y se discuten las mejores prácticas para mantener código limpio y reutilizable.

Organización: Individual o parejas.

Producto esperado: Informe con análisis y código refactorizado.

Duración estimada: 2 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre abstracción, clases abstractas y conceptos básicos de POO en Java.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas abiertas breves.

Instrumento sugerido: Test en línea o en papel con preguntas sobre definiciones, ejemplos y sintaxis básica.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión y aplicación de clases abstractas y UML, implementación de código y análisis crítico.

Cómo se evalúa: Observación y retroalimentación durante las actividades prácticas, revisión de productos parciales (diagramas, código, documentos).

Instrumento sugerido: Rúbrica para actividades prácticas, comentarios en foros o sesiones presenciales, revisión de entregables intermedios.

Evaluación Sumativa

Qué se evalúa: Dominio integral de los conceptos y habilidades: explicación, diseño UML, implementación en Java, análisis comparativo y evaluación de proyectos.

Cómo se evalúa: Proyecto final que incluya diseño UML, código Java con clases abstractas y subclases, análisis escrito comparativo entre clases abstractas e interfaces, y propuesta de mejora en código dado.

Instrumento sugerido: Rúbrica de evaluación que contemple claridad conceptual, corrección técnica, calidad del diseño, funcionalidad del código y profundidad del análisis crítico.

La unidad "Abstracción y Clases Abstractas" tiene una duración sugerida de 2 semanas, distribuidas en 10 horas presenciales y 5 horas de trabajo autónomo. La distribución recomendada es:

• Día 1 (3 horas): Introducción a la abstracción y clases abstractas; actividad de discusión conceptual.
• Día 2 (3 horas): Diseño UML y actividad práctica de modelado; presentación y retroalimentación.
• Día 3 (3 horas): Implementación en Java y actividad de codificación; revisión y pruebas.
• Día 4 (2 horas): Comparación clases abstractas vs interfaces y actividad de debate; evaluación formativa.
• Trabajo autónomo (5 horas): Preparación de proyecto final, estudio, lectura y elaboración de análisis crítico.

1. Introducción a las Interfaces en Java

• Concepto de interfaces: definición y propósito en Java.
• Diferencias entre clases abstractas e interfaces.
• Programación orientada a contratos: concepto y relevancia.
• Ventajas de usar interfaces en el diseño de sistemas.

2. Diseño de Interfaces como Contratos en Java

• Principios para definir contratos claros mediante interfaces.
• Especificación de métodos y constantes en interfaces.
• Interfaces funcionales y uso de anotaciones @FunctionalInterface.
• Buenas prácticas en la definición de interfaces para asegurar consistencia.

3. Implementación de Interfaces en Clases Java

• Sintaxis para implementar interfaces en clases.
• Obligatoriedad de implementar todos los métodos definidos en la interfaz.
• Ejemplos prácticos: implementación de múltiples interfaces.
• Relación entre interfaces y herencia múltiple en Java.

4. Análisis y Comparación de Diseños Basados en Interfaces

• Evaluación de la flexibilidad del código mediante interfaces.
• Mantenibilidad y escalabilidad en diseños orientados a contratos.
• Patrones de diseño comunes que utilizan interfaces (ej. Strategy, Observer).
• Comparación entre diseños con y sin interfaces: casos de estudio.

5. Aplicación de Principios de Programación Orientada a Contratos

• Concepto de programación orientada a contratos: precondiciones, postcondiciones e invariantes.
• Uso de interfaces para formalizar contratos y asegurar robustez.
• Integración de interfaces con pruebas unitarias para validar contratos.
• Mejora continua del software mediante la correcta utilización de interfaces.

1. Explorando Interfaces en Java

Objetivo: Explicar el concepto de interfaces y su papel en la programación orientada a contratos.

Descripción:

• Lectura guiada sobre la definición y características de interfaces en Java.
• Análisis en clase de ejemplos sencillos de interfaces y su implementación.
• Discusión grupal sobre las ventajas de usar interfaces en el diseño de sistemas.

Organización: Grupos pequeños (3-4 estudiantes).

Producto esperado: Resumen escrito y presentación breve de las ventajas de las interfaces.

Duración estimada: 1.5 horas.

2. Diseño de una Interfaz para un Sistema de Pago

Objetivo: Diseñar interfaces que definan contratos claros y específicos.

Descripción:

• Se plantea un escenario: diseñar una interfaz para métodos de pago.
• Los estudiantes crean la interfaz con métodos que deben implementar las clases que representen distintos tipos de pago (tarjeta, efectivo, transferencia).
• Revisión y retroalimentación entre pares para mejorar el diseño.

Organización: Parejas.

Producto esperado: Código Java con la interfaz diseñada y documento explicativo del contrato definido.

Duración estimada: 2 horas.

3. Implementación Práctica de Interfaces en Clases

Objetivo: Implementar interfaces para asegurar adherencia a contratos funcionales.

Descripción:

• Partiendo de la interfaz diseñada, cada estudiante implementa al menos dos clases que cumplan el contrato.
• Pruebas de funcionamiento para verificar que se cumplen los métodos definidos.
• Compartir y discutir los resultados en clase para identificar desafíos y soluciones.

Organización: Individual.

Producto esperado: Código funcional de clases que implementan la interfaz y reporte de pruebas.

Duración estimada: 3 horas.

4. Análisis Comparativo de Diseños Basados en Interfaces

Objetivo: Analizar y comparar diseños para evaluar impacto en flexibilidad y mantenibilidad.

Descripción:

• Presentación de dos diseños distintos: uno usando interfaces y otro sin ellas.
• Discusión guiada sobre ventajas y desventajas de cada enfoque.
• Elaboración de un informe que sintetice el análisis y proponga recomendaciones.

Organización: Grupos de 4 estudiantes.

Producto esperado: Informe de análisis comparativo.

Duración estimada: 2 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre interfaces y programación orientada a contratos.

Cómo se evalúa: Cuestionario corto de opción múltiple y preguntas abiertas.

Instrumento sugerido: Test en línea o en papel al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Progreso en el diseño e implementación de interfaces, comprensión de conceptos.

Cómo se evalúa: Revisión de actividades prácticas, participación en discusiones, retroalimentación entre pares.

Instrumento sugerido: Rubricas para diseño de interfaces y revisión de código.

Evaluación Sumativa

Qué se evalúa: Capacidad para diseñar, implementar y analizar interfaces de manera integral.

Cómo se evalúa: Proyecto final que incluye diseño de interfaces, implementación en clases Java y análisis crítico de diseño.

Instrumento sugerido: Entrega de proyecto con código y reporte escrito, presentaciones orales y prueba escrita final.

La unidad "Interfaces y Programación Orientada a Contratos" está diseñada para desarrollarse en 2 semanas, con una dedicación estimada de 12 horas distribuidas de la siguiente manera:

• Semana 1: 6 horas – Introducción, diseño de interfaces y actividades prácticas iniciales.
• Semana 2: 6 horas – Implementación, análisis comparativo, actividades de discusión y evaluación final.

1. Introducción al Manejo de Excepciones en Java

• Concepto de excepciones: definición y propósito en la programación.
• Tipos de errores: errores en tiempo de compilación, errores en tiempo de ejecución y errores lógicos.
• Ventajas de manejar excepciones en programas orientados a objetos.

2. Estructuras básicas para el manejo de excepciones en Java

• Bloques try-catch: sintaxis, funcionamiento y uso adecuado.
• Bloque finally: propósito y casos de uso.
• Múltiples bloques catch: manejo de diferentes tipos de excepciones.
• Uso de try con recursos (try-with-resources) para gestión automática de recursos.
• Jerarquía de excepciones en Java: checked exceptions, unchecked exceptions y errores.

3. Creación y uso de excepciones personalizadas

• Motivación para crear excepciones personalizadas en aplicaciones de ingeniería de sistemas.
• Definición de clases de excepciones personalizadas extendiendo Exception o RuntimeException.
• Incorporación de constructores y mensajes personalizados.
• Lanzamiento y captura de excepciones personalizadas en programas orientados a objetos.

4. Buenas prácticas en el manejo de excepciones

• Principios para un manejo efectivo y limpio de excepciones.
• Evitar capturar excepciones genéricas sin tratamiento específico.
• Uso adecuado del bloque finally para liberar recursos.
• Documentación y uso de throws en firmas de métodos.
• Impacto del manejo de excepciones en la mantenibilidad y robustez del software.

5. Análisis y corrección de errores mediante manejo de excepciones

• Detección de errores comunes en programas Java relacionados con excepciones.
• Depuración y uso de mensajes de error para identificar causas.
• Revisión y refactorización de código para mejorar el manejo de excepciones.
• Ejemplos prácticos de corrección de programas con errores mediante manejo adecuado de excepciones.

Actividad 1: Explorando las estructuras try-catch en Java

Objetivo: Identificar y clasificar las diferentes estructuras de manejo de excepciones en Java aplicando bloques try-catch.

Descripción:

• Se proporciona un conjunto de fragmentos de código Java con errores en tiempo de ejecución sin manejo de excepciones.
• Los estudiantes deben modificar el código para implementar bloques try-catch adecuados que capturen y manejen dichos errores.
• Analizar y clasificar cada excepción capturada según su tipo (checked, unchecked).

Organización: Individual

Producto esperado: Código modificado con manejo de excepciones correcto y un informe breve que clasifique las excepciones encontradas.

Duración estimada: 1.5 horas

Actividad 2: Desarrollo de excepciones personalizadas para un sistema de control de inventarios

Objetivo: Diseñar y desarrollar excepciones personalizadas en Java para necesidades específicas de gestión de errores.

Descripción:

• Se presenta un escenario de aplicación donde se debe controlar errores específicos (por ejemplo: producto no encontrado, cantidad insuficiente).
• Los estudiantes diseñan y crean clases de excepciones personalizadas para estos casos.
• Integran estas excepciones en un pequeño programa orientado a objetos que simule operaciones básicas del sistema.

Organización: Parejas

Producto esperado: Código fuente con excepciones personalizadas implementadas y un breve documento explicativo.

Duración estimada: 2 horas

Actividad 3: Análisis crítico y refactorización de código con manejo inadecuado de excepciones

Objetivo: Analizar y corregir errores en programas Java mediante el uso adecuado de estructuras de manejo de excepciones.

Descripción:

• Se entrega código con un manejo deficiente o incorrecto de excepciones (captura genérica, no liberación de recursos, etc.).
• Los estudiantes identifican los problemas, proponen mejoras y refactorizan el código para cumplir buenas prácticas.
• Se discuten los beneficios de los cambios implementados en términos de robustez y mantenibilidad.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Código refactorizado y presentación oral o escrita que justifique las mejoras.

Duración estimada: 2.5 horas

Actividad 4: Ejercicios prácticos de manejo de excepciones con try-with-resources

Objetivo: Implementar correctamente el manejo de recursos mediante try-with-resources para mejorar la robustez del software.

Descripción:

• Se entregan fragmentos de código que manejan archivos u otros recursos sin el uso de try-with-resources.
• Los estudiantes modifican el código para aplicar try-with-resources.
• Se realiza una prueba para verificar que los recursos se cierran correctamente y se manejan posibles excepciones.

Organización: Individual

Producto esperado: Código corregido funcional y breve reporte de pruebas realizadas.

Duración estimada: 1.5 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de excepciones y manejo de errores en programación.

Cómo se evalúa: Cuestionario escrito o en línea con preguntas teóricas y de reconocimiento de código con manejo de excepciones.

Instrumento sugerido: Prueba de opción múltiple y preguntas de desarrollo breve.

Evaluación Formativa

Qué se evalúa: Aplicación progresiva de conceptos en actividades prácticas, capacidad para diseñar excepciones personalizadas y refactorizar código.

Cómo se evalúa: Revisión continua de los productos de actividades, retroalimentación en clase y autoevaluación entre pares.

Instrumento sugerido: Rúbricas para evaluación de código, informes y presentaciones.

Evaluación Sumativa

Qué se evalúa: Dominio integral del manejo de excepciones, diseño de excepciones personalizadas, aplicación de buenas prácticas y análisis de errores.

Cómo se evalúa: Proyecto final donde se desarrolla una pequeña aplicación orientada a objetos con manejo completo y correcto de excepciones, más un examen escrito donde se analicen fragmentos de código y se respondan preguntas conceptuales.

Instrumento sugerido: Proyecto evaluado con rúbrica detallada y examen escrito.

La unidad "Manejo de Excepciones en Java" se recomienda impartir en un total de 8 horas distribuidas en dos semanas. Las primeras 3 horas se dedicarán a la introducción, explicación y práctica inicial de estructuras try-catch y jerarquía de excepciones. Las siguientes 3 horas se enfocarán en el diseño de excepciones personalizadas y las buenas prácticas recomendadas. Finalmente, 2 horas se reservarán para actividades de análisis, corrección de código y evaluación sumativa.

1. Introducción a las Colecciones en Java

• Definición y propósito de las colecciones en Java.
• Ventajas de usar colecciones frente a arreglos tradicionales.
• Jerarquía y principales interfaces del Framework de Colecciones (Collection, List, Set, Queue, Map).

2. Listas en Java

• Características y comportamiento de List.
• Implementaciones comunes: ArrayList, LinkedList.
• Operaciones básicas: inserción, eliminación, búsqueda y recorrido.
• Uso en problemas de ingeniería: ejemplos prácticos.

3. Conjuntos en Java

• Características y comportamiento de Set.
• Implementaciones comunes: HashSet, LinkedHashSet, TreeSet.
• Propiedades de unicidad y ordenamiento.
• Ejemplos de uso en la eliminación de duplicados y operaciones matemáticas (unión, intersección, diferencia).

4. Mapas en Java

• Descripción y uso de la interfaz Map.
• Implementaciones comunes: HashMap, LinkedHashMap, TreeMap.
• Claves y valores: almacenamiento y acceso eficiente.
• Ejemplos de aplicaciones: asociaciones clave-valor, tablas de búsqueda.

5. Introducción a los Genéricos en Java

• Concepto de genéricos y seguridad de tipos.
• Ventajas del uso de genéricos sobre colecciones sin tipo.
• Declaración y uso de colecciones genéricas.
• Restricciones y límites en genéricos (wildcards, bounded types).

6. Implementación y Manipulación de Colecciones Genéricas

• Creación y manipulación de Listas, Conjuntos y Mapas genéricos.
• Evitar conversiones de tipos y errores en tiempo de compilación.
• Recorridos usando iteradores y loops mejorados.
• Ejercicios prácticos que involucran colecciones genéricas.

7. Diseño de Programas con Colecciones y Genéricos

• Integración de colecciones genéricas en aplicaciones orientadas a objetos.
• Buenas prácticas en diseño para manejo eficiente de datos.
• Ejemplos de patrones de diseño que utilizan colecciones.
• Desarrollo de un proyecto simple que utilice colecciones y genéricos para resolver un problema real.

8. Análisis de Desempeño y Selección de Estructuras de Datos

• Comparación de complejidad temporal y espacial entre diferentes colecciones.
• Escenarios de uso recomendados para Listas, Conjuntos y Mapas.
• Evaluación de eficiencia según operaciones frecuentes (inserción, búsqueda, eliminación).
• Herramientas y técnicas para medir el desempeño en Java.

Actividad 1: Explorando Colecciones Básicas

Objetivo: Identificar y describir características y diferencias entre listas, conjuntos y mapas.

Descripción:

• El estudiante crea un programa Java que declare y manipule una List, un Set y un Map.
• Para cada colección, inserta datos, realiza búsquedas y elimina elementos.
• Documenta en un informe breve las diferencias observadas en comportamiento y uso.

Organización: Individual

Producto esperado: Código fuente con ejemplos y reporte de diferencias.

Duración estimada: 2 horas

Actividad 2: Implementación de Colecciones Genéricas Seguras

Objetivo: Implementar y manipular colecciones genéricas garantizando seguridad de tipos.

Descripción:

• El estudiante modifica el código del ejercicio anterior para usar colecciones genéricas con tipos específicos.
• Incluye ejemplos de uso de wildcards y bounded types.
• Realiza pruebas que evidencien la prevención de errores de tipo en tiempo de compilación.

Organización: Individual

Producto esperado: Código fuente documentado que demuestre el uso correcto de genéricos.

Duración estimada: 2 horas

Actividad 3: Desarrollo de un Programa con Colecciones para un Problema de Ingeniería

Objetivo: Diseñar y desarrollar un programa que utilice colecciones y genéricos para optimizar manejo de datos.

Descripción:

• En grupos, se propone un problema de ingeniería (por ejemplo, gestión de inventarios, registro de usuarios, análisis de datos).
• Se diseña una solución utilizando colecciones genéricas adecuadas (listas, conjuntos, mapas).
• Se desarrolla el programa y se documenta la elección de estructuras de datos con base en el problema.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Código funcional, documentación técnica y presentación breve del diseño.

Duración estimada: 4 horas (incluye diseño, codificación y presentación)

Actividad 4: Análisis Comparativo de Desempeño de Colecciones

Objetivo: Analizar desempeño y eficiencia de diferentes colecciones en Java y seleccionar estructuras adecuadas.

Descripción:

• El estudiante realiza experimentos midiendo tiempos de inserción, búsqueda y eliminación en ArrayList, LinkedList, HashSet y HashMap.
• Registra resultados y genera gráficos comparativos.
• Elabora un informe con conclusiones y recomendaciones para selección de colecciones según caso de uso.

Organización: Individual

Producto esperado: Informe con análisis y gráficos de desempeño.

Duración estimada: 3 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre estructuras de datos y colecciones básicas en Java.

Cómo se evalúa: Cuestionario en línea o presencial con preguntas conceptuales y código simple para interpretar.

Instrumento sugerido: Test de opción múltiple y preguntas cortas.

Evaluación Formativa

Qué se evalúa: Progreso en la implementación y comprensión práctica de colecciones y genéricos.

Cómo se evalúa: Revisión continua de código fuente, retroalimentación en actividades prácticas y participación en discusiones.

Instrumento sugerido: Rubricas para evaluación de código y reportes, sesiones de retroalimentación, foros de discusión.

Evaluación Sumativa

Qué se evalúa: Competencia para diseñar, implementar y analizar programas con colecciones y genéricos, y capacidad para seleccionar estructuras adecuadas.

Cómo se evalúa: Examen práctico y teórico que incluye:

• Resolución de problemas con uso correcto de listas, conjuntos y mapas.
• Implementación segura con genéricos.
• Análisis crítico del desempeño de colecciones.

Instrumento sugerido: Prueba escrita y práctica, proyecto final o caso de estudio con presentación.

La unidad "Colecciones y Genéricos" tiene una duración sugerida de 2 semanas, equivalentes a 12 horas de clase distribuidas de la siguiente manera:

• 4 horas para la explicación de conceptos teóricos y ejemplos (Temas 1 a 5).
• 6 horas para actividades prácticas y desarrollo de programas (Temas 6 y 7).
• 2 horas para análisis de desempeño, discusión y evaluación sumativa (Tema 8 y evaluaciones).

Se recomienda complementar con actividades de laboratorio y sesiones de consulta para resolver dudas y mejorar la comprensión.

1. Introducción a los Patrones de Diseño

• Concepto y propósito de los patrones de diseño en la programación orientada a objetos
• Beneficios de utilizar patrones: mantenibilidad, reutilización, escalabilidad y comunicación
• Clasificación general de los patrones de diseño: creacionales, estructurales y de comportamiento
• Breve historia y contexto del uso de patrones en ingeniería de software

2. Patrón Singleton

• Definición y motivación: garantizar una única instancia de una clase
• Características esenciales y estructura del patrón Singleton
• Implementación del patrón Singleton en Java: métodos estáticos, constructor privado
• Consideraciones y variantes: Singleton con inicialización perezosa, sincronización para entornos multihilo
• Ventajas y limitaciones en el diseño de software
• Ejemplos de aplicación práctica en sistemas reales
• Representación mediante diagramas UML: diagrama de clases y de secuencia

3. Patrón Factory

• Concepto y motivación: creación de objetos sin especificar la clase exacta
• Diferencias entre Factory Method y Abstract Factory (enfoque básico)
• Estructura y participantes del patrón Factory
• Implementación en Java: clases productoras y productos, uso de interfaces y clases abstractas
• Ventajas para la extensibilidad y desacoplamiento
• Ejemplo de aplicación en sistemas orientados a objetos
• Representación mediante diagramas UML: diagrama de clases y de interacción

4. Patrón Observer

• Definición y motivación: comunicación entre objetos con dependencia uno a muchos
• Estructura del patrón Observer: sujetos y observadores
• Implementación en Java: interfaces Observer y Subject, gestión de suscriptores y notificaciones
• Casos de uso comunes: interfaces gráficas, sistemas de eventos, modelos de datos reactivos
• Ventajas y posibles problemas (p. ej. acoplamiento, gestión de memoria)
• Representación UML: diagramas de clases y secuencia

5. Análisis de Problemas para Aplicación de Patrones

• Identificación de problemas comunes en el diseño de software orientado a objetos
• Mapeo de patrones Singleton, Factory y Observer a situaciones específicas
• Ejercicios de análisis de casos prácticos para determinar el patrón adecuado
• Discusión sobre alternativas y combinaciones de patrones

6. Implementación Práctica en Java

• Buenas prácticas de codificación y principios SOLID aplicados a los patrones
• Construcción paso a paso de cada patrón con ejemplos completos en Java
• Pruebas unitarias para validar la implementación
• Manejo de excepciones y condiciones especiales en la implementación

7. Impacto de los Patrones de Diseño en la Arquitectura del Software

• Evaluación de cómo los patrones afectan la mantenibilidad y escalabilidad
• Discusión sobre la modularidad y desacoplamiento
• Impacto en la facilidad de extensión y refactorización
• Comparación entre sistemas con y sin patrones

8. Documentación y Representación UML de Patrones

• Introducción a UML para patrones de diseño
• Diagramas de clases para representar la estructura de Singleton, Factory y Observer
• Diagramas de secuencia para ilustrar comportamiento y flujo de mensajes
• Buenas prácticas para la documentación técnica de patrones
• Ejercicios de creación y análisis de diagramas UML relacionados con patrones

Actividad 1: Análisis y Discusión de Patrones en Casos Reales

Objetivo: Explicar los conceptos y características de los patrones Singleton, Factory y Observer.

Descripción:

• Se presentan varios casos de sistemas o aplicaciones conocidas o hipotéticas.
• Los estudiantes identifican qué patrón(es) de diseño se aplican o podrían aplicarse.
• Discusión guiada en clase sobre el porqué de la elección y las características del patrón.
• Se realiza un resumen grupal para consolidar conceptos.

Organización: Grupos pequeños de 3-4 estudiantes.

Producto esperado: Informe escrito o presentación corta que justifique la aplicación del patrón.

Duración estimada: 1.5 horas.

Actividad 2: Implementación Guiada de Patrones en Java

Objetivo: Implementar en Java los patrones Singleton, Factory y Observer respetando buenas prácticas y principios SOLID.

Descripción:

• El docente proporciona ejemplos base y fragmentos de código.
• Los estudiantes completan o desarrollan desde cero la implementación de cada patrón en Java.
• Se realizan pruebas unitarias para validar el correcto funcionamiento.
• Se enfatiza la aplicación de principios SOLID y buenas prácticas durante la codificación.

Organización: Individual.

Producto esperado: Código fuente en Java y reporte de pruebas.

Duración estimada: 3 horas.

Actividad 3: Diseño UML de Soluciones con Patrones

Objetivo: Documentar y representar mediante diagramas UML la estructura y comportamiento de las soluciones con patrones Singleton, Factory y Observer.

Descripción:

• Se proporcionan casos de estudio o las implementaciones realizadas en la actividad anterior.
• Los estudiantes elaboran diagramas de clases y secuencia para cada patrón aplicado.
• Se realiza revisión cruzada entre grupos para retroalimentación.

Organización: Parejas o grupos pequeños.

Producto esperado: Conjunto de diagramas UML bien documentados.

Duración estimada: 2 horas.

Actividad 4: Evaluación del Impacto de Patrones en un Caso de Estudio

Objetivo: Evaluar el impacto de la aplicación de patrones en la arquitectura, mantenibilidad y escalabilidad.

Descripción:

• Se presenta un sistema básico sin patrones y su versión refactorizada con patrones.
• Los estudiantes analizan y comparan aspectos de arquitectura, mantenibilidad y escalabilidad.
• Discusión grupal para presentar conclusiones y recomendaciones.

Organización: Grupos de 4-5 estudiantes.

Producto esperado: Ensayo o presentación que detalle el análisis y conclusiones.

Duración estimada: 2 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre patrones de diseño y conceptos básicos de programación orientada a objetos.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas abiertas sobre conceptos generales de patrones y ejemplos simples.

Instrumento sugerido: Test en plataforma educativa o examen escrito breve al iniciar la unidad.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión, análisis, implementación y documentación de los patrones Singleton, Factory y Observer.

Cómo se evalúa: Revisión continua de actividades prácticas, retroalimentación en implementaciones Java, análisis de casos y diagramas UML.

Instrumento sugerido: Rúbricas para código, informes escritos y diagramas; participación en discusiones de clase.

Evaluación Sumativa

Qué se evalúa: Dominio integral de los patrones de diseño básicos: explicación, análisis, implementación, evaluación y documentación.

Cómo se evalúa: Proyecto final individual o grupal que incluya:

• Análisis de un problema de diseño y selección adecuada de patrones
• Implementación en Java de los patrones correspondientes
• Documentación con diagramas UML detallados
• Ensayo o presentación evaluando el impacto en arquitectura y mantenibilidad

Instrumento sugerido: Rúbrica de proyecto final con criterios para cada aspecto mencionado.

La unidad "Patrones de Diseño Básicos" se recomienda desarrollar en un periodo de 3 semanas, distribuidas de la siguiente manera:

• Semana 1: Introducción a patrones y estudio del patrón Singleton. Actividad de análisis y discusión.
• Semana 2: Estudio de patrones Factory y Observer. Implementación guiada de los tres patrones en Java.
• Semana 3: Diseño UML, evaluación del impacto de los patrones y desarrollo del proyecto final. Actividades de documentación y presentación.

Se estiman aproximadamente 10 horas presenciales o sincrónicas y 5 horas de trabajo autónomo para actividades prácticas y estudio.

1. Introducción a UML y su importancia en el modelado orientado a objetos

• Concepto y propósito de UML en ingeniería de software
• Principios básicos de la programación orientada a objetos y su relación con UML
• Visión general de los tipos de diagramas UML y su clasificación
• Herramientas comunes para el modelado UML

2. Diagramas de Clases UML

• Elementos básicos: clases, atributos, métodos
• Visibilidad: pública, privada, protegida y paquete
• Relaciones entre clases: asociación, agregación, composición y herencia
• Multiplicidad y roles en asociaciones
• Interfaces y clases abstractas
• Ejemplos prácticos de diagramas de clases

3. Diagramas de Objetos UML

• Diferencias entre diagramas de clases y diagramas de objetos
• Instancias de clases y representación gráfica
• Estado de los objetos en el diagrama
• Uso para ilustrar escenarios específicos del sistema
• Ejemplos y análisis de diagramas de objetos

4. Diagramas de Secuencia UML

• Propósito y uso en la representación del comportamiento dinámico
• Elementos del diagrama: objetos/participantes, líneas de vida, mensajes
• Tipos de mensajes: síncronos, asíncronos, retornos
• Fragmentos combinados: alternativas, opciones y bucles
• Construcción y análisis de diagramas de secuencia para casos de uso

5. Herramientas para el modelado UML

• Introducción a herramientas populares (StarUML, Visual Paradigm, PlantUML, etc.)
• Funcionalidades clave para creación y edición de diagramas
• Exportación, documentación y estándares UML en herramientas
• Buenas prácticas para el uso de herramientas UML en proyectos académicos y profesionales

6. Análisis y mejora de diagramas UML

• Identificación de inconsistencias comunes en diagramas UML
• Detección de redundancias y problemas en relaciones y dependencias
• Optimización de diagramas para claridad y mantenibilidad
• Revisión crítica y retroalimentación en grupos
• Documentación de cambios y versiones de diagramas

Actividad 1: Interpretación guiada de diagramas UML

Objetivo: Interpretar diagramas de clases, objetos y secuencia para identificar componentes y relaciones (Objetivo 1)

• Se proporcionan varios diagramas UML reales o simulados.
• Los estudiantes analizan cada diagrama, identificando clases, atributos, métodos, relaciones, objetos y mensajes.
• Discusión en plenaria para validar interpretaciones y resolver dudas.

Organización: Individual y luego discusión grupal

Producto esperado: Informe breve con la descripción de los elementos y relaciones encontrados en cada diagrama

Duración estimada: 1.5 horas

Actividad 2: Diseño colaborativo de diagramas UML para un sistema dado

Objetivo: Diseñar diagramas UML que representen requisitos funcionales (Objetivo 2)

• Se entrega un conjunto de requisitos funcionales para un sistema sencillo (ejemplo: sistema de gestión de biblioteca).
• En grupos, los estudiantes diseñan diagramas de clases, objetos y secuencia que reflejen los requisitos.
• Uso de una herramienta UML para realizar los diagramas.
• Presentación y retroalimentación entre grupos.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Conjunto de diagramas UML digitales (clases, objetos, secuencia) del sistema propuesto

Duración estimada: 3 horas (2 para diseño y 1 para presentación)

Actividad 3: Práctica con herramientas de modelado UML

Objetivo: Aplicar herramientas UML para documentar diseños conforme a estándares (Objetivo 3)

• Capacitación breve sobre la herramienta seleccionada (por ejemplo, StarUML o PlantUML).
• Ejercicios prácticos para crear y editar diagramas UML, exportar y documentar.
• Creación de un mini proyecto con diagramas funcionales y documentación asociada.

Organización: Individual

Producto esperado: Proyecto digital con diagramas UML bien documentados y exportados

Duración estimada: 2 horas

Actividad 4: Análisis crítico y mejora de diagramas UML

Objetivo: Analizar diagramas UML para detectar inconsistencias o mejoras (Objetivo 4)

• Se proporcionan diagramas UML con errores o áreas de mejora intencionales.
• Los estudiantes identifican problemas y proponen soluciones.
• Discusión en grupo para comparar enfoques y consensuar mejoras.
• Aplicación de correcciones en una herramienta UML.

Organización: Parejas

Producto esperado: Informe con análisis de problemas y diagramas corregidos

Duración estimada: 2 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de UML y programación orientada a objetos.

Cómo se evalúa: Cuestionario escrito o en línea con preguntas de opción múltiple y preguntas cortas para identificar nivel inicial.

Instrumento sugerido: Test diagnóstico de 15 preguntas al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Desarrollo progresivo de habilidades para interpretar, diseñar y documentar diagramas UML.

• Revisión continua de tareas y actividades prácticas (actividades 1, 2 y 3).
• Retroalimentación personalizada durante las sesiones de trabajo.
• Autoevaluación y coevaluación en actividades grupales.

Instrumento sugerido: Rúbricas para evaluación de diagramas, checklists de interpretación y participación en discusiones.

Evaluación Sumativa

Qué se evalúa: Competencia para interpretar, diseñar, aplicar herramientas y analizar diagramas UML de manera integral.

Cómo se evalúa: Proyecto final individual o en pareja que incluye:

• Interpretación de un conjunto de diagramas UML para un sistema dado.
• Diseño completo de diagramas UML (clases, objetos, secuencia) para un caso de estudio.
• Documentación generada con herramienta UML conforme a estándares.
• Análisis crítico del diseño con propuestas de mejora.

Instrumento sugerido: Rúbrica detallada que evalúe precisión, calidad técnica, uso de herramientas y profundidad analítica.

La unidad "Diagramas UML para Modelado de Sistemas" se recomienda impartirla en 2 semanas académicas, con un total aproximado de 10 horas distribuidas así:

• Semana 1 (5 horas): Introducción a UML, diagramas de clases y diagramas de objetos, incluyendo actividad 1 y parte de la actividad 2.
• Semana 2 (5 horas): Diagramas de secuencia, herramientas UML, análisis y mejora de diagramas, completando actividad 2, actividad 3 y actividad 4, finalizando con evaluación sumativa.

1. Planificación del Proyecto de Software

• 1.1 Definición del alcance del proyecto: Conceptualización del problema, delimitación del alcance funcional y no funcional, identificación de restricciones y supuestos.
• 1.2 Técnicas de análisis orientado a objetos para requisitos: Identificación de actores, escenarios y requisitos funcionales mediante técnicas como entrevistas, historias de usuario y análisis de casos de uso.
• 1.3 Documentación de requisitos funcionales: Estructuración y formalización de los requisitos para su posterior modelado.

2. Diseño de Diagramas UML para el Modelado del Sistema

• 2.1 Diagramas de casos de uso: Identificación de actores, definición de casos de uso, relaciones entre ellos y diagramación.
• 2.2 Diagramas de clases: Identificación de clases, atributos, métodos, relaciones (asociación, herencia, agregación, composición) y diagramación.
• 2.3 Diagramas de secuencia: Modelado de la interacción dinámica entre objetos para los casos de uso seleccionados.

3. Elaboración del Esquema Inicial en Java

• 3.1 Mapeo de clases UML a código Java: Creación de clases, atributos y métodos en Java según el diseño UML.
• 3.2 Definición de interfaces y métodos públicos: Establecimiento de contratos y encapsulación.
• 3.3 Organización inicial del paquete del proyecto: Estructura de carpetas y archivos Java para mantener un proyecto organizado.

4. Aplicación de Principios SOLID y Patrones de Diseño Básicos

• 4.1 Principios SOLID: Explicación y aplicación práctica de cada principio para mejorar la calidad del código.
• 4.2 Patrones de diseño básicos: Introducción y aplicación de patrones como Singleton, Factory Method y Observer para resolver problemas comunes de diseño.
• 4.3 Estrategias para lograr alta cohesión y bajo acoplamiento: Técnicas para modularizar el proyecto y facilitar mantenimiento y escalabilidad.

5. Documentación y Presentación del Plan y Diseño Inicial

• 5.1 Elaboración de reportes técnicos: Estructura, contenido y formato para documentar el alcance, requisitos, diseño UML, y decisiones de diseño.
• 5.2 Preparación de presentaciones efectivas: Técnicas para comunicar claramente las decisiones y justificaciones del proyecto.
• 5.3 Uso de herramientas para documentación y presentación: Plataformas recomendadas para la documentación colaborativa y presentaciones (ej. Word, PowerPoint, herramientas UML).

Actividad 1: Análisis y Definición del Alcance y Requisitos Funcionales

Objetivo: Planificar el alcance y los requisitos funcionales del proyecto aplicando técnicas de análisis orientado a objetos.

Descripción:

• Se asigna un problema o proyecto integrador de software.
• Los estudiantes identifican los actores y describen los escenarios principales mediante entrevistas simuladas o análisis documental.
• Generan una lista de requisitos funcionales priorizados y delimitan el alcance del proyecto.
• Presentan un documento con el análisis realizado.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Documento de alcance y requisitos funcionales.

Duración estimada: 3 horas.

Actividad 2: Diseño de Diagramas UML

Objetivo: Diseñar diagramas UML (casos de uso, clases y secuencia) para modelar la estructura y comportamiento del sistema.

Descripción:

• Con base en el documento de requisitos, elaboran diagramas de casos de uso identificando actores y relaciones.
• Diseñan diagramas de clases con atributos, métodos y relaciones.
• Elaboran diagramas de secuencia para al menos dos casos de uso prioritarios.
• Utilizan herramientas UML para realizar los diagramas.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Conjunto de diagramas UML digitales.

Duración estimada: 4 horas.

Actividad 3: Codificación Inicial en Java a partir del Diseño UML

Objetivo: Elaborar un esquema inicial de clases y métodos en Java que refleje el diseño orientado a objetos definido en los diagramas UML.

Descripción:

• Mapean las clases del diagrama UML a clases Java, definiendo atributos y métodos.
• Implementan interfaces y clases base con métodos principales.
• Organizan el proyecto Java en paquetes siguiendo buenas prácticas.
• Realizan una revisión cruzada entre los miembros del grupo para asegurar coherencia con el diseño UML.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Proyecto Java con estructura inicial de clases y métodos.

Duración estimada: 4 horas.

Actividad 4: Aplicación de Principios SOLID y Patrones de Diseño

Objetivo: Aplicar principios SOLID y patrones de diseño básicos para estructurar el proyecto con alta cohesión y bajo acoplamiento.

Descripción:

• Analizan el código Java inicial y detectan posibles violaciones a los principios SOLID.
• Refactorizan el código para aplicar los principios, ejemplificando con uno o dos patrones de diseño básicos.
• Documentan las decisiones de diseño y explican los beneficios obtenidos.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Código refactorizado y documento con justificación de las decisiones de diseño.

Duración estimada: 4 horas.

Actividad 5: Documentación y Presentación del Proyecto Integrador

Objetivo: Documentar y presentar el plan y diseño inicial del proyecto integrador, justificando las decisiones tomadas.

Descripción:

• Consolidan toda la documentación generada (alcance, requisitos, diagramas UML, código, principios aplicados).
• Preparan una presentación oral apoyada en diapositivas para explicar el proyecto, diseño y decisiones.
• Realizan la presentación ante el grupo y docente, atendiendo preguntas y comentarios.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Reporte final y presentación oral.

Duración estimada: 3 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre análisis orientado a objetos, UML y principios básicos de diseño.

Cómo se evalúa: Cuestionario de selección múltiple y preguntas abiertas cortas.

Instrumento sugerido: Test en línea o en papel al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Progreso en actividades de análisis, diseño, codificación, aplicación de principios y documentación.

Cómo se evalúa: Revisión y retroalimentación continua de los entregables parciales (documentos de requisitos, diagramas UML, código Java, documentos de refactorización).

Instrumento sugerido: Listas de cotejo y rúbricas específicas para cada actividad.

Evaluación Sumativa

Qué se evalúa: Producto final completo que incluye el plan de proyecto, diagramas UML, código Java inicial con aplicación de principios SOLID y patrones, y la presentación oral.

Cómo se evalúa: Calificación basada en rúbrica que considere calidad técnica, coherencia entre etapas, aplicación correcta de conceptos y claridad en la presentación.

Instrumento sugerido: Rúbrica integral que abarque aspectos técnicos, documentales y comunicativos.

La unidad "Desarrollo de un Proyecto Integrador I" está diseñada para ser impartida en un total de 18 horas distribuidas en 4 semanas, con la siguiente distribución aproximada:

• Semana 1: Planificación del proyecto y análisis de requisitos (3 horas).
• Semana 2: Diseño de diagramas UML (4 horas).
• Semana 3: Codificación inicial y aplicación de principios SOLID y patrones de diseño (8 horas).
• Semana 4: Documentación final y presentación del proyecto integrador (3 horas).

Esta distribución permite un equilibrio entre la teoría y la práctica, garantizando que los estudiantes desarrollen competencias integrales para la planificación y diseño inicial de proyectos de software orientados a objetos.

1. Implementación de funcionalidades complejas en Java aplicando principios avanzados de POO

• Revisión de principios SOLID y su aplicación práctica en el proyecto
• Integración de módulos: comunicación y dependencia entre clases y paquetes
• Uso avanzado de herencia, interfaces y clases abstractas
• Gestión de excepciones personalizadas y manejo robusto de errores
• Implementación de colecciones genéricas y estructuras de datos avanzadas

2. Diseño y ejecución de pruebas unitarias y de integración en Java

• Introducción a frameworks de pruebas: JUnit 5 y Mockito
• Diseño de casos de prueba para funcionalidades individuales (pruebas unitarias)
• Pruebas de integración para validar la interacción entre módulos
• Automatización de pruebas: integración con herramientas de construcción (Maven, Gradle)
• Interpretación de resultados y reporte de cobertura de código

3. Aplicación de buenas prácticas de codificación y patrones de diseño

• Estándares de codificación en Java: nomenclatura, estructura y comentarios
• Principales patrones de diseño aplicados al proyecto: Singleton, Factory, Observer, Strategy
• Refactorización orientada a mejorar la legibilidad y reducir la complejidad
• Uso de herramientas estáticas para análisis de código (SonarQube, PMD)

4. Identificación y corrección de errores mediante depuración y refactorización

• Técnicas avanzadas de depuración con IDEs (Eclipse, IntelliJ IDEA)
• Localización de defectos y análisis de pila de llamadas
• Refactorización segura: extracción de métodos, renombrado y simplificación de lógica
• Optimización de rendimiento y gestión eficiente de recursos

5. Documentación del proyecto integrador

• Documentación de arquitectura: diagramas UML (clases, secuencia, componentes)
• Documentación de diseño: explicaciones de patrones y decisiones técnicas
• Documentación de pruebas: casos, resultados y cobertura
• Buenas prácticas para mantener documentación actualizada y accesible
• Uso de herramientas para generación automática de documentación (Javadoc, PlantUML)

Implementación avanzada de módulos integrados

Objetivo: Implementar funcionalidades complejas aplicando principios avanzados de POO y asegurar la integración correcta de módulos.

Descripción:

• Se asigna un conjunto de funcionalidades complejas que integran varios módulos del proyecto.
• El estudiante debe diseñar y codificar dichas funcionalidades aplicando principios SOLID y buenas prácticas.
• Realizar pruebas manuales iniciales para validar la integración.
• Documentar brevemente la integración y los patrones aplicados.

Organización: Individual o en parejas

Producto esperado: Código Java funcional integrado con documentación técnica parcial.

Duración estimada: 6 horas

Diseño y ejecución de pruebas unitarias y de integración con JUnit y Mockito

Objetivo: Diseñar y ejecutar pruebas que validen el comportamiento esperado del proyecto.

Descripción:

• Identificar funciones críticas para probar.
• Escribir pruebas unitarias utilizando JUnit 5 para esas funciones.
• Crear pruebas de integración que involucren múltiples módulos, utilizando Mockito para simular dependencias.
• Ejecutar pruebas y analizar resultados, ajustando el código si es necesario.

Organización: Individual

Producto esperado: Suite de pruebas automatizadas con reportes de ejecución.

Duración estimada: 5 horas

Aplicación de patrones de diseño y refactorización

Objetivo: Mejorar el código usando patrones de diseño y técnicas de refactorización para aumentar la calidad y mantenibilidad.

Descripción:

• Analizar fragmentos de código con problemas de diseño o mantenibilidad.
• Aplicar uno o más patrones de diseño para resolver problemas detectados.
• Refactorizar el código para simplificar la lógica y mejorar la legibilidad.
• Documentar los cambios realizados y justificar la elección de patrones.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Código refactorizado con documentación de patrones aplicados.

Duración estimada: 6 horas

Documentación integral del proyecto integrador

Objetivo: Documentar la arquitectura, diseño, pruebas y aspectos relevantes del proyecto para facilitar comprensión y mantenimiento.

Descripción:

• Crear diagramas UML que representen la arquitectura y el diseño del proyecto.
• Redactar la documentación explicativa de patrones, decisiones técnicas y estructura del código.
• Documentar los casos de prueba, resultados y cobertura obtenida.
• Generar documentación técnica usando herramientas como Javadoc y PlantUML.
• Preparar un informe final que consolide toda la documentación.

Organización: Individual o en parejas

Producto esperado: Documento técnico completo y diagramas UML organizados.

Duración estimada: 4 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre programación orientada a objetos avanzada, pruebas y patrones de diseño.

Cómo se evalúa: Cuestionario teórico-práctico breve y análisis de código suministrado.

Instrumento sugerido: Test en línea o escrito con preguntas de opción múltiple y ejercicios cortos.

Evaluación formativa

Qué se evalúa: Progreso en la implementación, diseño de pruebas, aplicación de patrones y documentación.

Cómo se evalúa: Revisión continua de entregas parciales, retroalimentación en actividades prácticas y seguimiento con rúbricas específicas.

Instrumento sugerido: Rúbricas detalladas para código, pruebas, documentación y presentaciones orales o escritas.

Evaluación sumativa

Qué se evalúa: Producto final del proyecto integrador con funcionalidades completas, pruebas automatizadas, código refactorizado y documentación exhaustiva.

Cómo se evalúa: Presentación y entrega del proyecto, revisión de código, ejecución de pruebas y análisis de documentación.

Instrumento sugerido: Rúbrica de evaluación integral que cubra calidad del código, cobertura de pruebas, aplicación de patrones, calidad de documentación y desempeño en la presentación final.

La unidad "Desarrollo de un Proyecto Integrador II" tiene una duración sugerida de 3 semanas, con una dedicación aproximada de 21 horas distribuidas de la siguiente forma: 8 horas para implementación y pruebas iniciales, 6 horas para refactorización y aplicación de patrones de diseño, 4 horas para la documentación completa del proyecto y 3 horas para actividades de evaluación, revisión y retroalimentación.

1. Introducción a la optimización y refactorización de código

• Definición y objetivos de la optimización y la refactorización
• Diferencias entre optimización y refactorización
• Importancia de la mantenibilidad y el rendimiento en proyectos Java orientados a objetos
• Criterios para identificar código que requiere mejora

2. Análisis de código para identificar oportunidades de mejora

• Lectura y comprensión de fragmentos de código Java
• Detección de código duplicado y estructuras complejas
• Identificación de cuellos de botella y problemas de rendimiento básicos
• Herramientas para análisis estático de código (p. ej., SonarQube, PMD)

3. Técnicas de refactorización orientadas a objetos

• Extracción de métodos: cuándo y cómo aplicarla
• Eliminación de código duplicado y consolidación de lógica repetida
• Renombrado de variables y métodos para mejorar la legibilidad
• Reorganización de clases y métodos para una mejor cohesión y acoplamiento
• Refactorización basada en patrones de diseño comunes

4. Aplicación de principios SOLID para mejorar el diseño

• Repaso de los principios SOLID: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
• Modificación y diseño de clases y métodos en Java según SOLID
• Ejemplos prácticos de refactorización aplicando SOLID para facilitar la escalabilidad
• Beneficios de SOLID en la mantenibilidad y optimización del código

5. Evaluación del impacto de la refactorización y optimización

• Introducción a métricas de calidad de código (complejidad ciclomática, cobertura de pruebas, etc.)
• Pruebas de rendimiento: conceptos básicos y técnicas en Java
• Uso de herramientas para medir rendimiento (Java VisualVM, JMH)
• Validación de que la funcionalidad se mantiene tras los cambios

6. Uso de herramientas y entornos de desarrollo para automatizar refactorización y optimización

• Capacidades de refactorización automática en IDEs populares (Eclipse, IntelliJ IDEA, NetBeans)
• Configuración y uso de plugins para análisis y optimización de código
• Integración de análisis estático y pruebas de rendimiento en el flujo de desarrollo
• Buenas prácticas para el uso de herramientas en proyectos Java orientados a objetos

Actividad 1: Análisis y diagnóstico de fragmentos de código Java

Objetivo: Analizar fragmentos de código en Java para identificar oportunidades de optimización y refactorización (Objetivo 1).

Descripción:

• Se entregan varios fragmentos de código Java con problemas comunes de mantenibilidad y rendimiento.
• Los estudiantes revisan individualmente cada fragmento para identificar errores, código duplicado, complejidad innecesaria o malas prácticas.
• Se realiza una discusión grupal donde cada estudiante presenta sus hallazgos y se contrastan las observaciones.

Organización: Individual para análisis y grupal para discusión.

Producto esperado: Informe breve con las oportunidades de mejora detectadas para cada fragmento.

Duración estimada: 1.5 horas.

Actividad 2: Refactorización práctica aplicando extracción de métodos y eliminación de código duplicado

Objetivo: Aplicar técnicas de refactorización orientadas a objetos para mejorar estructura y legibilidad (Objetivo 2).

Descripción:

• En parejas, los estudiantes reciben un módulo Java con código duplicado y métodos muy largos.
• Deberán aplicar extracción de métodos para segmentar funcionalidades y eliminar código repetido reusando lógica común.
• Se documentarán los cambios realizados y justificarán las decisiones tomadas.

Organización: Parejas.

Producto esperado: Código refactorizado y un documento explicativo de las técnicas aplicadas.

Duración estimada: 2 horas.

Actividad 3: Rediseño de clases siguiendo principios SOLID

Objetivo: Diseñar y modificar clases y métodos en Java con principios SOLID para optimizar diseño y escalabilidad (Objetivo 3).

Descripción:

• Se entrega un conjunto de clases Java con problemas de diseño (alta dependencia, responsabilidades mixtas, etc.).
• Individualmente, los estudiantes deben reestructurar el diseño aplicando cada principio SOLID, creando nuevas interfaces o clases según corresponda.
• Se compara el antes y después para evaluar mejoras en cohesión, acoplamiento y escalabilidad.

Organización: Individual.

Producto esperado: Código rediseñado y un análisis escrito que explique cómo se aplicaron los principios SOLID.

Duración estimada: 2.5 horas.

Actividad 4: Medición del impacto de refactorización mediante pruebas y métricas

Objetivo: Evaluar el impacto de cambios en el código con pruebas de rendimiento y métricas de calidad (Objetivo 4).

Descripción:

• En grupos de tres, los estudiantes ejecutan pruebas de rendimiento y análisis de métricas antes y después de una refactorización realizada previamente.
• Utilizan herramientas como Java VisualVM y plugins de IDE para obtener métricas.
• Interpretan los resultados y elaboran un informe que describa el impacto sobre funcionalidad, rendimiento y mantenibilidad.

Organización: Grupos de tres.

Producto esperado: Informe de evaluación con gráficos y conclusiones sobre la calidad y desempeño del código.

Duración estimada: 3 horas.

Actividad 5: Uso de IDE para automatizar refactorización y optimización

Objetivo: Utilizar herramientas y entornos de desarrollo para automatizar procesos de refactorización y optimización (Objetivo 5).

Descripción:

• Se realiza una sesión práctica guiada donde el docente demuestra funcionalidades de refactorización automática en un IDE (IntelliJ IDEA o Eclipse).
• Los estudiantes replican las acciones en sus propios equipos, aplicando renombrado, extracción de métodos, y análisis estático.
• Se configura un proyecto para integrar análisis de calidad y pruebas automáticas dentro del flujo de trabajo.

Organización: Individual.

Producto esperado: Proyecto Java con refactorización aplicada mediante IDE y configuración de análisis automatizados.

Duración estimada: 2 horas.

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre refactorización, optimización y principios básicos de diseño orientado a objetos.

Cómo se evalúa: Cuestionario escrito o en línea con preguntas de opción múltiple y breves ejercicios de identificación de problemas en fragmentos de código.

Instrumento sugerido: Test diagnóstico con preguntas teóricas y prácticas, administrado al inicio de la unidad.

Evaluación formativa

Qué se evalúa: Progreso en la identificación de problemas, aplicación de técnicas de refactorización, comprensión y uso de principios SOLID, y manejo de herramientas IDE.

Cómo se evalúa: Revisión continua de productos intermedios de las actividades, retroalimentación en sesiones prácticas, autoevaluaciones y coevaluaciones entre pares.

Instrumento sugerido: Listas de cotejo para actividades prácticas, rúbricas para informes y código entregado, participación en discusiones.

Evaluación sumativa

Qué se evalúa: Capacidad integral para analizar, refactorizar, rediseñar y evaluar código Java orientado a objetos aplicando los conocimientos y técnicas aprendidas.

Cómo se evalúa: Proyecto final donde el estudiante entrega un módulo Java refactorizado y optimizado, acompañado de pruebas y análisis de impacto, y una memoria técnica explicativa.

Instrumento sugerido: Rúbrica detallada que valore calidad del código, aplicación de técnicas, uso de principios SOLID, resultados de pruebas y calidad del informe.

La unidad "Optimización y Refactorización de Código" está diseñada para desarrollarse en un total de 12 horas distribuidas idealmente en 4 semanas, con una carga de 3 horas por semana. La distribución sugerida es:

• Semana 1 (3 horas): Introducción y análisis de código (Temas 1 y 2), junto con la Actividad 1.
• Semana 2 (3 horas): Técnicas de refactorización y aplicación práctica (Temas 3 y 4), con Actividades 2 y 3.
• Semana 3 (3 horas): Evaluación del impacto y uso de herramientas (Temas 5 y 6), desarrollando Actividad 4.
• Semana 4 (3 horas): Consolidación práctica con Actividad 5 y preparación para evaluación sumativa.

Este diseño permite un avance progresivo desde la comprensión teórica hasta la aplicación práctica y evaluación integral, facilitando la asimilación y dominio de los contenidos por parte de los estudiantes.

1. Preparación para la Presentación del Proyecto Final

• Revisión y organización del proyecto: estructura, código y documentación.
• Terminología y conceptos clave de la programación orientada a objetos: clases, objetos, herencia, polimorfismo, encapsulación, abstracción.
• Elaboración de una presentación técnica clara y coherente: guion, recursos visuales y tiempos.
• Preparación para la defensa: anticipación de preguntas y argumentación técnica.

2. Exposición y Defensa del Proyecto Integrador

• Metodología para la exposición oral: estructura de la presentación, comunicación efectiva y uso de terminología técnica.
• Demostración práctica del proyecto: funcionalidades principales y arquitectura orientada a objetos.
• Defensa del diseño y decisiones técnicas: justificación de patrones de diseño y principios aplicados.
• Manejo de preguntas y retroalimentación en tiempo real.

3. Análisis Crítico de Resultados y Evaluación Técnica

• Evaluación de la calidad del software: criterios como mantenibilidad, escalabilidad, reutilización y eficiencia.
• Identificación de fortalezas en el proyecto: aspectos destacados del diseño y la implementación.
• Detección de áreas de mejora: problemas técnicos, optimización y buenas prácticas no aplicadas.
• Uso de métricas y herramientas para análisis de código y calidad de software.

4. Aplicación de Retroalimentación y Optimización del Proyecto

• Interpretación de la retroalimentación recibida durante la evaluación.
• Estrategias para mejorar diseño e implementación basadas en observaciones.
• Refactorización del código y optimización del desempeño.
• Validación de mejoras y documentación actualizada.

5. Evaluación de la Integración de Patrones de Diseño y Principios OOP

• Identificación y análisis de patrones de diseño implementados en el proyecto.
• Justificación del impacto de estos patrones en la mantenibilidad y funcionalidad del sistema.
• Relación entre principios de programación orientada a objetos y la calidad final del software.
• Presentación crítica de cómo la aplicación de estos conceptos afecta el ciclo de vida del proyecto.

Actividad 1: Preparación y Ensayo de la Presentación del Proyecto

Objetivo: Desarrollar la capacidad de exponer y defender el proyecto integrador utilizando terminología y conceptos clave de programación orientada a objetos.

Descripción:

• Revisar y organizar el contenido técnico y visual de la presentación.
• Elaborar un guion que incluya explicación de la arquitectura, funcionalidades y patrones de diseño.
• Practicar la exposición frente a compañeros para recibir retroalimentación.
• Incluir respuestas a preguntas anticipadas sobre diseño y código.

Organización: Individual o en parejas para práctica de defensa.

Producto esperado: Presentación preparada con guion y recursos visuales, ensayo documentado.

Duración estimada: 3 horas.

Actividad 2: Exposición y Defensa Formal del Proyecto

Objetivo: Exponer y defender el proyecto integrador demostrando comprensión técnica y argumentación coherente.

Descripción:

• Presentar el proyecto ante el docente y compañeros, explicando arquitectura, funcionalidades y patrones OOP aplicados.
• Responder preguntas técnicas y defender decisiones de diseño.
• Demostrar la aplicación práctica de conceptos de programación orientada a objetos.

Organización: Individual.

Producto esperado: Presentación oral con defensa técnica ante el grupo y docente.

Duración estimada: 1 hora por estudiante o grupo según tamaño.

Actividad 3: Análisis Crítico y Evaluación del Proyecto Final

Objetivo: Analizar críticamente los resultados del proyecto, identificando fortalezas y áreas de mejora basadas en criterios de calidad de software.

Descripción:

• Revisar el código, documentación y presentación del proyecto.
• Aplicar métricas y criterios técnicos para evaluar calidad, mantenibilidad y desempeño.
• Redactar un informe crítico que incluya observaciones y sugerencias para mejora.

Organización: Individual o en grupos pequeños para discusión y análisis.

Producto esperado: Informe crítico con análisis técnico y recomendaciones.

Duración estimada: 4 horas.

Actividad 4: Implementación de Mejoras Basadas en Retroalimentación

Objetivo: Aplicar retroalimentación para optimizar diseño, implementación y desempeño del proyecto en Java.

Descripción:

• Revisar el informe de retroalimentación recibido.
• Planificar y ejecutar mejoras en el código y diseño, incluyendo refactorización.
• Actualizar documentación y preparar una breve presentación de las mejoras realizadas.

Organización: Individual.

Producto esperado: Versión mejorada del proyecto con documentación actualizada y presentación de cambios.

Duración estimada: 5 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre exposición técnica, terminología OOP y preparación para defensa de proyectos.

Cómo se evalúa: Cuestionario inicial y discusión breve sobre conceptos clave y habilidades de comunicación técnica.

Instrumento sugerido: Cuestionario en línea o papel con preguntas abiertas y de opción múltiple.

Evaluación Formativa

Qué se evalúa: Progreso en preparación de la presentación, capacidad de argumentación, análisis crítico y aplicación de retroalimentación.

Cómo se evalúa: Observación de ensayos de presentación, revisión de informes críticos preliminares y seguimiento de mejoras implementadas.

Instrumento sugerido: Rúbrica para evaluación de presentaciones prácticas, retroalimentación escrita del docente y revisión de borradores.

Evaluación Sumativa

Qué se evalúa: Calidad de la exposición y defensa del proyecto, análisis crítico final, justificación del diseño y aplicación de patrones OOP, y mejoras aplicadas.

Cómo se evalúa: Presentación oral final, informe crítico definitivo y entrega del proyecto mejorado.

Instrumento sugerido: Rúbrica integral que contemple criterios técnicos, comunicación, análisis crítico y calidad del producto final.

La unidad tiene una duración sugerida de 3 semanas, distribuidas de la siguiente manera:

• Semana 1: Preparación y ensayo de la presentación (3 horas de trabajo guiado y autónomo).
• Semana 2: Exposición y defensa formal del proyecto (1 hora por estudiante o grupo, según calendario).
• Semana 3: Análisis crítico, recepción y aplicación de retroalimentación, y entrega final mejorada (5 horas de trabajo autónomo y tutoría).

Esta distribución permite integrar el aprendizaje práctico con la reflexión crítica y la mejora continua, asegurando un cierre significativo del curso.