Entornos de Desarrollo - Unidad 5 - Sesión 6: Diseño de Sistemas Complejos Usando Diagramas de Clases

Objetivos de la sesión

Diseñar sistemas más complejos combinando conceptos de herencia, composición, y agregación.
Trabajar en un ejercicio integrador para crear un sistema completo a partir de requisitos.
Desarrollar un diagrama de clases desde cero, implementarlo en código y validarlo con un programa principal.

Estructura de la sesión

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

Construcción de sistemas complejos: claves de diseño

Identificar entidades clave:
- Determinar las clases principales a partir del enunciado del problema.
- Identificar atributos y métodos básicos de cada entidad.
Establecer relaciones entre clases:
- Analizar cómo interactúan las entidades.
- Decidir si las relaciones son de herencia, composición o agregación.
Crear el diagrama de clases:
- Representar las entidades y sus relaciones gráficamente.
Validar el diseño:
- Revisar si el diagrama es consistente con los requisitos planteados.

Mejores prácticas:

Cada clase debe tener una responsabilidad clara (Principio de Responsabilidad Única).
Reducir la dependencia entre clases (bajo acoplamiento).
Preferir composición sobre herencia cuando sea posible.

2. Ejercicio guiado: Diseño de un sistema de gestión de cursos (45 minutos)

Descripción:
Diseñar un sistema de gestión de cursos para una academia.
Los Cursos tienen un nombre, una duración y un listado de Estudiantes.
Cada Estudiante tiene un nombre, una edad y un correo electrónico.
Los Profesores imparten uno o más cursos.
La academia tiene una lista de profesores y cursos.

Paso 1: Diseñar el diagrama de clases

El profesor guía a los estudiantes para construir el diagrama de clases en la pizarra o en herramientas UML.

Diagrama esperado:

----------------------
| Academia           |
----------------------
| + nombre: String   |
| + cursos: Curso[]  |
| + profesores: Profesor[] |
----------------------
| + mostrarInfo(): void |
----------------------
          ◆
          |
----------------------
| Curso              |
----------------------
| + nombre: String   |
| + duracion: int    |
| + estudiantes: Estudiante[] |
| + profesor: Profesor |
----------------------
| + mostrarInfo(): void |
----------------------
          ◆            ◇
          |            |
---------------------- ----------------------
| Estudiante         | | Profesor           |
---------------------- ----------------------
| + nombre: String   | | + nombre: String   |
| + edad: int        | | + especialidad: String |
| + email: String    | | + cursos: Curso[]  |
---------------------- ----------------------
| + mostrarInfo(): void | | + mostrarInfo(): void |
---------------------- ----------------------

Paso 2: Implementar el código en Java

Los estudiantes convierten el diagrama de clases en código siguiendo las relaciones y métodos definidos.

Código base para el profesor:

public class Estudiante {
    public String nombre;
    public int edad;
    public String email;

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

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

public class Profesor {
    public String nombre;
    public String especialidad;
    public Curso[] cursos;

    public Profesor(String nombre, String especialidad, Curso[] cursos) {
        this.nombre = nombre;
        this.especialidad = especialidad;
        this.cursos = cursos;
    }

    public void mostrarInfo() {
        System.out.println("Profesor: " + nombre + ", Especialidad: " + especialidad);
        System.out.println("Cursos impartidos:");
        for (Curso curso : cursos) {
            System.out.println("- " + curso.nombre);
        }
    }
}

public class Curso {
    public String nombre;
    public int duracion; // En horas
    public Estudiante[] estudiantes;
    public Profesor profesor;

    public Curso(String nombre, int duracion, Estudiante[] estudiantes, Profesor profesor) {
        this.nombre = nombre;
        this.duracion = duracion;
        this.estudiantes = estudiantes;
        this.profesor = profesor;
    }

    public void mostrarInfo() {
        System.out.println("Curso: " + nombre + ", Duración: " + duracion + " horas");
        System.out.println("Profesor: " + profesor.nombre);
        System.out.println("Estudiantes:");
        for (Estudiante estudiante : estudiantes) {
            estudiante.mostrarInfo();
        }
    }
}

public class Academia {
    public String nombre;
    public Curso[] cursos;
    public Profesor[] profesores;

    public Academia(String nombre, Curso[] cursos, Profesor[] profesores) {
        this.nombre = nombre;
        this.cursos = cursos;
        this.profesores = profesores;
    }

    public void mostrarInfo() {
        System.out.println("Academia: " + nombre);
        System.out.println("Cursos:");
        for (Curso curso : cursos) {
            curso.mostrarInfo();
            System.out.println("-------------------");
        }
        System.out.println("Profesores:");
        for (Profesor profesor : profesores) {
            profesor.mostrarInfo();
            System.out.println("-------------------");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Estudiante est1 = new Estudiante("Juan", 18, "juan@email.com");
        Estudiante est2 = new Estudiante("María", 19, "maria@email.com");
        Estudiante est3 = new Estudiante("Pedro", 20, "pedro@email.com");

        Profesor prof1 = new Profesor("Carlos", "Matemáticas", null);
        Profesor prof2 = new Profesor("Laura", "Programación", null);

        Curso curso1 = new Curso("Matemáticas Básicas", 40, new Estudiante[] { est1, est2 }, prof1);
        Curso curso2 = new Curso("Introducción a Java", 60, new Estudiante[] { est2, est3 }, prof2);

        prof1.cursos = new Curso[] { curso1 };
        prof2.cursos = new Curso[] { curso2 };

        Academia academia = new Academia("Academia Tech", new Curso[] { curso1, curso2 }, new Profesor[] { prof1, prof2 });

        academia.mostrarInfo();
    }
}

3. Actividad en grupo: Diseño colaborativo de un sistema (45 minutos)

Descripción:
Los estudiantes trabajarán en grupos para diseñar un sistema desde cero.

Problema:

Diseñar un sistema para gestionar una tienda de música:

Los Clientes pueden alquilar Instrumentos.
La Tienda tiene un listado de instrumentos y clientes registrados.
Los Instrumentos tienen un tipo (cuerda, viento, percusión).
Los Clientes pueden devolver los instrumentos después de usarlos.

Tareas del grupo:

Crear el diagrama de clases con las entidades y relaciones necesarias.
Validar el diseño con el profesor.
Implementar el código en Java.

4. Resolución y cierre (15 minutos)

Debate:
- ¿Qué desafíos enfrentaron al diseñar sistemas más complejos?
- ¿Qué aprenderían de los diagramas generados automáticamente en sistemas grandes?
Avance para la siguiente sesión:
- Conceptos básicos de pruebas en programación orientada a objetos.

Apuntes para el profesor

Supervisión:
- Asegurarse de que los estudiantes distingan entre composición y agregación correctamente en sus diseños.
- Ayudar a los grupos a organizar correctamente los atributos y métodos de las clases.
Material necesario:

Herramientas de diagramación UML (papel o software).
Código base para ejercicios.

Sesión 7

VelvetBit

Buscar este blog