Entornos de Desarrollo - Unidad 5 - Sesión 5: Generación de Diagramas de Clases a partir de Código (Ingeniería Inversa)

Objetivos de la sesión

1. Comprender el concepto de ingeniería inversa en programación orientada a objetos.
2. Utilizar herramientas para generar diagramas de clases a partir de código existente.
3. Interpretar y validar los diagramas generados automáticamente.
4. Practicar el análisis de código y diagramas de clases para asegurar la correspondencia entre ambos.

---

Estructura de la sesión

1. Introducción teórica (20 minutos)

---

¿Qué es la ingeniería inversa?

• Definición:
  Es el proceso de analizar el código fuente para reconstruir el diseño del sistema en forma de diagramas o modelos, como los diagramas de clases UML.
• ¿Por qué es útil?
  • Para comprender sistemas existentes sin documentación.
  • Para identificar problemas o inconsistencias en el diseño.
  • Para generar documentación técnica automáticamente.

Herramientas que soportan ingeniería inversa:

• Eclipse con el plugin ObjectAid UML Explorer.
• IntelliJ IDEA con UML plugin.
• Visual Paradigm.
• NetBeans con soporte UML.

---

2. Ejercicio guiado: Ingeniería inversa con código proporcionado (45 minutos)

---

Descripción:
Los alumnos utilizarán un conjunto de clases en Java y generarán un diagrama de clases a partir de este código.

Pasos para los estudiantes:

1. Revisar el código base proporcionado por el profesor.
2. Utilizar herramientas UML para generar automáticamente el diagrama de clases.
3. Comparar el diagrama generado con el código para identificar correspondencias e inconsistencias.

Código base para los estudiantes:

public class Persona {
    public String nombre;
    public int edad;

    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public void mostrarInfo() {
        System.out.println("Nombre: " + nombre + ", Edad: " + edad);
    }
}

public class Empleado extends Persona {
    public String puesto;

    public Empleado(String nombre, int edad, String puesto) {
        super(nombre, edad);
        this.puesto = puesto;
    }

    public void mostrarInfo() {
        super.mostrarInfo();
        System.out.println("Puesto: " + puesto);
    }
}

public class Empresa {
    public String nombre;
    private Empleado[] empleados;

    public Empresa(String nombre, Empleado[] empleados) {
        this.nombre = nombre;
        this.empleados = empleados;
    }

    public void mostrarInfo() {
        System.out.println("Empresa: " + nombre);
        for (Empleado empleado : empleados) {
            empleado.mostrarInfo();
            System.out.println("-------------------");
        }
    }
}

---

Instrucciones del ejercicio:

1. Instalar y configurar ObjectAid UML Explorer (si se usa Eclipse) o cualquier herramienta UML sugerida.
2. Importar el proyecto en el entorno de desarrollo.
3. Generar el diagrama de clases automáticamente.
4. Responder a las siguientes preguntas:
   • ¿Qué relaciones aparecen en el diagrama?
   • ¿El diagrama refleja correctamente la herencia, composición y asociaciones?
   • ¿Qué cambios harías en el diseño de estas clases?

---

3. Ejercicio de análisis de diagramas (45 minutos)

---

Descripción:
Analizar diagramas generados automáticamente y corregir posibles inconsistencias en el diseño del código.

Diagrama de clases proporcionado:

El profesor debe preparar un diagrama generado a partir del siguiente código (o un equivalente).
Ejemplo:

Clase: Persona  
Atributos: nombre (String), edad (int)  
Métodos: mostrarInfo()  

Clase: Empleado (hereda de Persona)  
Atributos: puesto (String)  
Métodos: mostrarInfo()  

Clase: Empresa  
Atributos: nombre (String), empleados (Empleado[])  
Métodos: mostrarInfo()  

Tareas para los estudiantes:

1. Identificar elementos clave en el diagrama:
   • Clases, atributos y métodos.
   • Relaciones (herencia, composición, agregación).
2. Responder preguntas de análisis:
   • ¿Qué clase tiene la relación de herencia?
   • ¿Dónde se encuentra la relación de composición?
   • ¿Cómo se representa la asociación entre Empleado y Empresa?
3. Proponer mejoras al diseño del código base, si corresponde.

---

4. Resolución y discusión grupal (30 minutos)

---

• Preguntas para debate:

  1. ¿El diagrama generado automáticamente representa todo el diseño del sistema?
  2. ¿Qué elementos del diagrama podrían mejorarse o ajustarse?
  3. ¿Qué aprendiste al comparar el diagrama con el código base?

• Demostración:
  El profesor puede realizar el ejercicio en vivo, generando un diagrama de clases y corrigiendo cualquier inconsistencia en el diseño.

---

Apuntes para el profesor

---

Solución del ejercicio guiado:

---

Diagrama esperado:

----------------------
| Persona            |
----------------------
| + nombre: String   |
| + edad: int        |
----------------------
| + mostrarInfo(): void |
----------------------
          ▲
          |
----------------------
| Empleado           |
----------------------
| + puesto: String   |
----------------------
| + mostrarInfo(): void |
----------------------
          ◇
          |
----------------------
| Empresa            |
----------------------
| + nombre: String   |
| + empleados: Empleado[] |
----------------------
| + mostrarInfo(): void |
----------------------

Elementos clave:

• La herencia entre Persona y Empleado aparece correctamente representada con una flecha.
• La relación de composición entre Empresa y Empleado se refleja con un rombo negro (composición).

---

Posibles inconsistencias a corregir:

1. Los modificadores de acceso: En el código base, algunos atributos están públicos cuando deberían ser privados o protegidos.
2. El uso de arrays: Podría mejorarse utilizando colecciones en el futuro.

---

Material necesario:

1. Diagrama de clases predefinido para análisis.
2. Código fuente preparado.
3. Software de generación de diagramas (configurado previamente).

Sesión 6