Entornos de Desarrollo - Unidad 5 - Sesión 4: Generación de Código a partir de Diagramas de Clases

Objetivos de la sesión

Aprender a generar código Java a partir de un diagrama de clases.
Comprender el proceso de transformación de un diseño UML en una implementación de software.
Practicar la implementación de relaciones (herencia, composición y agregación) mediante ejercicios guiados.

Estructura de la sesión

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

Del diagrama al código: Pasos básicos

Análisis del diagrama de clases
- Identificar clases, atributos, métodos y relaciones.
- Determinar cuál relación corresponde a herencia, composición o agregación.
Creación de las clases en código:
- Traducir cada clase del diagrama en una clase Java.
- Implementar los atributos y métodos según se detalla en el diagrama.
Implementación de las relaciones:
- Herencia: Usar extends.
- Composición: Crear instancias dentro de la clase contenedora.
- Agregación: Recibir las instancias desde fuera (por parámetros o setters).
Pruebas y uso:
- Crear un programa principal (main) que permita instanciar y probar las clases.

Herramientas que facilitan la generación automática de código (opcional, breve mención)

Si el entorno de desarrollo tiene herramientas de modelado UML, se puede usar la función de "generar código". Algunos ejemplos:

Eclipse UML Generator
IntelliJ IDEA con el plugin UML Designer
Visual Paradigm

Esto se explorará más adelante en sesiones avanzadas.

2. Ejercicio guiado 1: Implementar un sistema basado en un diagrama (45 minutos)

Descripción:
Diseñar e implementar un sistema de gestión de biblioteca.
Una Biblioteca contiene Libros (composición).
Cada Libro tiene un Autor (agregación).
Autor y Libro comparten un método para mostrar su información.

Tareas para los estudiantes:

Estudiar el diagrama de clases proporcionado.
Implementar las clases en Java.
Crear un programa principal que:
- Cree una biblioteca con varios libros.
- Asocie autores con libros.
- Imprima la información de la biblioteca.

Diagrama de clases (proporcionado a los alumnos):

----------------------
| Biblioteca         |
----------------------
| + nombre: String   |
| + libros: Libro[]  |
----------------------
| + mostrarInfo(): void |
----------------------
          ◆
          |
----------------------
| Libro              |
----------------------
| + titulo: String   |
| + autor: Autor     |
----------------------
| + mostrarInfo(): void |
----------------------
          ◇
          |
----------------------
| Autor              |
----------------------
| + nombre: String   |
----------------------
| + mostrarInfo(): void |
----------------------

Solución para el profesor:

Código en Java:

public class Autor {
    public String nombre;

    public Autor(String nombre) {
        this.nombre = nombre;
    }

    public void mostrarInfo() {
        System.out.println("Autor: " + nombre);
    }
}

public class Libro {
    public String titulo;
    public Autor autor; // Relación de agregación

    public Libro(String titulo, Autor autor) {
        this.titulo = titulo;
        this.autor = autor;
    }

    public void mostrarInfo() {
        System.out.println("Título: " + titulo);
        autor.mostrarInfo(); // Delegar al método de Autor
    }
}

public class Biblioteca {
    public String nombre;
    private Libro[] libros; // Relación de composición

    public Biblioteca(String nombre, Libro[] libros) {
        this.nombre = nombre;
        this.libros = libros;
    }

    public void mostrarInfo() {
        System.out.println("Biblioteca: " + nombre);
        System.out.println("Libros disponibles:");
        for (Libro libro : libros) {
            libro.mostrarInfo();
            System.out.println("-------------------");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Autor autor1 = new Autor("Gabriel García Márquez");
        Autor autor2 = new Autor("J.K. Rowling");

        Libro libro1 = new Libro("Cien años de soledad", autor1);
        Libro libro2 = new Libro("Harry Potter y la piedra filosofal", autor2);

        Biblioteca biblioteca = new Biblioteca("Biblioteca Central", new Libro[] { libro1, libro2 });

        biblioteca.mostrarInfo();
    }
}

3. Ejercicio guiado 2: Relaciones avanzadas (1 hora)

Descripción:
Implementar un sistema para gestionar una tienda de videojuegos.
Una Tienda tiene una lista de Videojuegos (composición).
Cada Videojuego pertenece a una Categoría (agregación).
Implementar métodos para mostrar los videojuegos de una categoría específica.

Tareas para los estudiantes:

Diseñar el diagrama de clases (guiado por el profesor).
Implementar el código Java.
Crear un programa que:
- Cree una tienda con varios videojuegos.
- Permita buscar videojuegos por categoría.

Diagrama de clases: (Se construye colaborativamente con los alumnos durante la clase)

----------------------
| Tienda             |
----------------------
| + nombre: String   |
| + videojuegos: Videojuego[] |
----------------------
| + mostrarVideojuegos(): void |
| + buscarPorCategoria(cat: Categoria): void |
----------------------
          ◆
          |
----------------------
| Videojuego         |
----------------------
| + titulo: String   |
| + categoria: Categoria |
----------------------
| + mostrarInfo(): void |
----------------------
          ◇
          |
----------------------
| Categoria          |
----------------------
| + nombre: String   |
----------------------
| + mostrarInfo(): void |
----------------------

Solución para el profesor:

Código en Java:

public class Categoria {
    public String nombre;

    public Categoria(String nombre) {
        this.nombre = nombre;
    }

    public void mostrarInfo() {
        System.out.println("Categoría: " + nombre);
    }
}

public class Videojuego {
    public String titulo;
    public Categoria categoria;

    public Videojuego(String titulo, Categoria categoria) {
        this.titulo = titulo;
        this.categoria = categoria;
    }

    public void mostrarInfo() {
        System.out.println("Título: " + titulo);
        categoria.mostrarInfo();
    }
}

public class Tienda {
    public String nombre;
    private Videojuego[] videojuegos;

    public Tienda(String nombre, Videojuego[] videojuegos) {
        this.nombre = nombre;
        this.videojuegos = videojuegos;
    }

    public void mostrarVideojuegos() {
        System.out.println("Videojuegos en la tienda " + nombre + ":");
        for (Videojuego vj : videojuegos) {
            vj.mostrarInfo();
            System.out.println("-------------------");
        }
    }

    public void buscarPorCategoria(Categoria categoria) {
        System.out.println("Videojuegos en la categoría: " + categoria.nombre);
        for (Videojuego vj : videojuegos) {
            if (vj.categoria == categoria) {
                vj.mostrarInfo();
                System.out.println("-------------------");
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Categoria categoria1 = new Categoria("Aventura");
        Categoria categoria2 = new Categoria("Acción");

        Videojuego juego1 = new Videojuego("The Legend of Zelda", categoria1);
        Videojuego juego2 = new Videojuego("Uncharted", categoria1);
        Videojuego juego3 = new Videojuego("Call of Duty", categoria2);

        Tienda tienda = new Tienda("GameStore", new Videojuego[] { juego1, juego2, juego3 });

        tienda.mostrarVideojuegos();
        tienda.buscarPorCategoria(categoria1);
    }
}

4. Resumen y preguntas finales (15 minutos)

Preguntas clave:
1. ¿Cómo diferenciar entre composición y agregación en un problema?
2. ¿Qué pasos seguirías para convertir un diagrama de clases en código?
Avance para la siguiente sesión:
- Generación inversa: crear diagramas de clases a partir de código existente.

Apuntes para el profesor

Supervisar el diseño del diagrama en el Ejercicio 2 y asegurarse de que los estudiantes incluyan correctamente las relaciones y métodos.
Priorizar la correcta implementación de los constructores y el uso de los métodos mostrarInfo() para respetar la encapsulación y claridad del código.

Sesión 5

VelvetBit

Buscar este blog