Ir al contenido principal

Entornos de Desarrollo - Unidad 5 - Sesión 2: Relaciones en los diagramas de clases (Asociación y uso)

Objetivos de la sesión

  1. Comprender y representar las relaciones básicas en los diagramas de clases: asociación y uso.
  2. Implementar las relaciones entre clases en código Java.
  3. Desarrollar la habilidad para identificar relaciones a partir de una descripción textual.

Estructura de la sesión

1. Explicación teórica (30-40 minutos)

Relación de asociación

  • Definición:
    Representa una conexión lógica entre dos clases. Indica que los objetos de una clase están relacionados con los objetos de otra clase.

    • Ejemplo: "Un Profesor enseña un Curso".
    • Puede tener multiplicidad, que define el número de objetos relacionados:
      • 1: uno.
      • *: muchos.
      • 0..1: opcional (cero o uno).

  • Notación:
    Se dibuja una línea entre las clases con posibles multiplicidades en los extremos:

    Profesor 1 ----------- * Curso

  • Traducción a código:

    • Un objeto de una clase se almacena como atributo en la otra clase.

    Ejemplo:

    public class Profesor {
    public String nombre;
    public Curso curso;  // Asociación: un profesor tiene un curso
}

public class Curso {
    public String nombreCurso;
}

Relación de uso

  • Definición:
    Una clase utiliza a otra para realizar ciertas operaciones, pero no almacena una relación permanente.

    • Ejemplo: "Un Estudiante usa un Libro para estudiar."
    • Es una relación temporal.

  • Notación:
    Se representa con una línea punteada con una flecha en un sentido:

    Estudiante --------> Libro

  • Traducción a código:

    • La clase que usa recibe un objeto de la otra clase como parámetro en un método.

    Ejemplo:

    public class Estudiante {
    public void usarLibro(Libro libro) {
        System.out.println("El estudiante está estudiando con el libro: " + libro.titulo);
    }
}

public class Libro {
    public String titulo;
}

Diferencia clave: Asociación vs. Uso

  • Asociación: Relación permanente o duradera (almacenada como atributo).
  • Uso: Relación temporal (se utiliza en un método).

2. Ejercicios prácticos (2-2.5 horas)

Ejercicio 1: Asociación entre Profesor y Curso

Descripción:
Queremos modelar el sistema académico de una escuela. Cada profesor enseña uno o varios cursos.

  • Un Profesor tiene los siguientes atributos:
    • nombre (cadena de texto).
    • cursos (array de objetos de tipo Curso).
  • Un Curso tiene:
    • nombreCurso (cadena de texto).
    • codigoCurso (entero).

Tareas para los estudiantes:

  1. Diseñar un diagrama de clases para representar esta relación.
  2. Implementar las clases en Java.
  3. Crear un programa que:
    • Cree un profesor con varios cursos.
    • Muestre la información del profesor y los cursos que enseña.

Solución para el profesor:

  • Diagrama de clases:

    -----------------------
| Profesor            |
-----------------------
| + nombre: String    |
| + cursos: Curso[]   |
-----------------------
| + mostrarCursos(): void |
-----------------------
              ^
              |
-----------------------
| Curso                |
-----------------------
| + nombreCurso: String |
| + codigoCurso: int    |
-----------------------
| + mostrarInformacion(): void |
-----------------------

  • Código en Java:

    public class Curso {
    public String nombreCurso;
    public int codigoCurso;

    public void mostrarInformacion() {
        System.out.println("Curso: " + nombreCurso + ", Código: " + codigoCurso);
    }
}

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

    public void mostrarCursos() {
        System.out.println("Profesor: " + nombre);
        System.out.println("Cursos que enseña:");
        for (Curso curso : cursos) {
            curso.mostrarInformacion();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Crear cursos
        Curso curso1 = new Curso();
        curso1.nombreCurso = "Matemáticas";
        curso1.codigoCurso = 101;

        Curso curso2 = new Curso();
        curso2.nombreCurso = "Física";
        curso2.codigoCurso = 102;

        // Crear profesor
        Profesor profesor = new Profesor();
        profesor.nombre = "Carlos Pérez";
        profesor.cursos = new Curso[] { curso1, curso2 };

        // Mostrar información
        profesor.mostrarCursos();
    }
}

Ejercicio 2: Uso entre Estudiante y Libro

Descripción:
En una biblioteca, un estudiante usa libros para estudiar.

  • Un Estudiante tiene:
    • nombre (cadena de texto).
  • Un Libro tiene:
    • titulo (cadena de texto).
  • El estudiante puede usar un libro para estudiar, lo cual se representa en un método llamado usarLibro(Libro libro).

Tareas para los estudiantes:

  1. Diseñar el diagrama de clases para representar esta relación de uso.
  2. Implementar las clases en Java.
  3. Crear un programa que:
    • Cree un estudiante y un libro.
    • Haga que el estudiante use el libro para estudiar.

Solución para el profesor:

  • Diagrama de clases:

    ---------------------
| Estudiante         |
---------------------
| + nombre: String   |
---------------------
| + usarLibro(libro: Libro): void |
---------------------
             -------->
---------------------
| Libro             |
---------------------
| + titulo: String  |
---------------------

  • Código en Java:

    public class Libro {
    public String titulo;
}

public class Estudiante {
    public String nombre;

    public void usarLibro(Libro libro) {
        System.out.println(nombre + " está estudiando con el libro: " + libro.titulo);
    }
}

public class Main {
    public static void main(String[] args) {
        // Crear libro
        Libro libro = new Libro();
        libro.titulo = "Introducción a Java";

        // Crear estudiante
        Estudiante estudiante = new Estudiante();
        estudiante.nombre = "Ana López";

        // Usar el libro
        estudiante.usarLibro(libro);
    }
}

3. Resumen y preguntas finales (15-20 minutos)

  1. Revisión de los conceptos clave:

    • Diferencia entre asociación y uso.
    • Cómo identificar estas relaciones en una descripción textual.
    • Cómo traducirlas a diagramas y luego a código.

  2. Preguntas para la reflexión:

    • ¿Qué sucede si cambian los atributos en una de las clases relacionadas?
    • ¿Podría un estudiante usar varios libros? ¿Cómo lo modelaríamos?

  3. Avance para la próxima sesión:

    • Introducción a relaciones más avanzadas: herencia y su representación en diagramas de clases.

Apuntes del profesor

  • Material necesario: Pizarra, hojas para diagramas, herramientas como Lucidchart o StarUML (opcional).
  • Tiempo estimado por ejercicio:
    • Ejercicio 1: 60-75 minutos.
    • Ejercicio 2: 45-60 minutos.
  • Consejo:
    • Supervisar los diagramas y revisar que las multiplicidades sean correctas antes de que los alumnos escriban código.
    • En el Ejercicio 2, preguntar a los estudiantes cómo implementarían el uso de múltiples libros por un estudiante para fomentar el análisis.
Etiquetas:

Comentarios

Publicar un comentario