Ir al contenido principal

Entornos de Desarrollo - Unidad 5 - Sesión 1: Introducción a los diagramas de clases y la programación orientada a objetos

Objetivos

  1. Identificar los conceptos básicos de la Programación Orientada a Objetos (POO).
  2. Comprender la notación básica de diagramas de clases: clases, atributos, métodos y visibilidad.
  3. Crear diagramas de clases simples a partir de una descripción textual.
  4. Traducir diagramas de clases a código en Java.

Estructura de la sesión

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

Introducción a la POO

  1. Conceptos clave:

    • Clase: Plantilla o molde que define las propiedades (atributos) y comportamientos (métodos) de los objetos.
    • Objeto: Instancia de una clase; un elemento concreto con atributos definidos.
    • Atributo: Propiedad o característica de un objeto.
    • Método: Comportamiento o función que realiza un objeto.

    Ejemplo práctico:

    • Clase: Persona
      • Atributos: nombre, edad.
      • Métodos: saludar().
    • Objeto: Una persona específica como Juan, 20 años.

  2. Notación básica de los diagramas de clases:
    Los diagramas de clases se utilizan para representar visualmente las clases de un programa, sus atributos, métodos y relaciones.

    • Estructura de una clase en un diagrama:
      -----------------
| NombreClase    |
-----------------
| + atributo1    |
| - atributo2    |
-----------------
| + metodo1()    |
| - metodo2()    |
-----------------
      • + Público: Visible para cualquier clase.
      • - Privado: Solo accesible desde dentro de la misma clase.
      • # Protegido: Visible para la clase y sus subclases.

  3. Flujo básico de trabajo con diagramas de clases:

    • Paso 1: Leer y analizar la descripción del problema.
    • Paso 2: Identificar las clases, atributos y métodos principales.
    • Paso 3: Crear el diagrama de clases.
    • Paso 4: Traducir el diagrama a código.

  4. Ejemplo introductorio (para explicar en clase):

    Descripción: Queremos modelar una clase llamada Persona con un atributo nombre y un método saludar().

    • Diagrama de clases:
      -----------------
| Persona        |
-----------------
| + nombre: String|
-----------------
| + saludar(): void|
-----------------
    • Código en Java:
      public class Persona {
    public String nombre;

    public void saludar() {
        System.out.println("Hola, soy " + nombre);
    }
}

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

Ejercicio 1: Modelar la clase Estudiante

Descripción:
Queremos modelar un estudiante con los siguientes atributos y métodos:

  • Atributos: nombre (cadena de texto), edad (entero), numeroMatricula (entero).
  • Métodos: inscribirse() (sin parámetros, imprime un mensaje) y consultarInformacion() (sin parámetros, imprime los datos del estudiante).

Tareas para los estudiantes:

  1. Dibujar el diagrama de clases en papel o con herramientas digitales.
  2. Implementar la clase en Java.

Solución para el profesor:

  • Diagrama de clases:

    ----------------------------
| Estudiante               |
----------------------------
| + nombre: String         |
| + edad: int              |
| + numeroMatricula: int   |
----------------------------
| + inscribirse(): void    |
| + consultarInformacion(): void |
----------------------------

  • Código en Java:

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

    public void inscribirse() {
        System.out.println("El estudiante " + nombre + " se ha inscrito.");
    }

    public void consultarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
        System.out.println("Número de matrícula: " + numeroMatricula);
    }
}

Ejercicio 2: Relación entre Estudiante y Curso

Descripción:
Ampliemos el ejercicio anterior. Ahora, cada estudiante pertenece a un curso. Un curso tiene:

  • Atributos: nombreCurso (cadena de texto) y codigoCurso (entero).
  • Métodos: mostrarInformacion() (sin parámetros, imprime los datos del curso).

Tareas para los estudiantes:

  1. Diseñar las clases Estudiante y Curso con sus relaciones.
  2. Implementar ambas clases en Java, haciendo que Estudiante contenga un atributo que sea una instancia de Curso.

Solución para el profesor:

  • Diagrama de clases:

    ----------------------------
| Estudiante               |
----------------------------
| + nombre: String         |
| + edad: int              |
| + numeroMatricula: int   |
| + curso: Curso           |
----------------------------
| + inscribirse(): void    |
| + consultarInformacion(): 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("Nombre del curso: " + nombreCurso);
        System.out.println("Código del curso: " + codigoCurso);
    }
}

public class Estudiante {
    public String nombre;
    public int edad;
    public int numeroMatricula;
    public Curso curso;

    public void inscribirse() {
        System.out.println("El estudiante " + nombre + " se ha inscrito en el curso " + curso.nombreCurso);
    }

    public void consultarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
        System.out.println("Número de matrícula: " + numeroMatricula);
        curso.mostrarInformacion();
    }
}

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

  1. Reforzar conceptos clave:

    • ¿Qué es una clase y cómo se representa en un diagrama de clases?
    • ¿Cómo pasamos de un texto descriptivo a un diagrama y luego al código?

  2. Preguntas para la reflexión:

    • ¿Qué sucede si cambiamos los atributos o métodos en el diagrama?
    • ¿Cómo se relacionan las clases entre sí?

Apuntes del profesor

  • Material necesario: Marcadores, pizarra, hojas para diagramas (opcional), herramientas digitales (Lucidchart o StarUML).
  • Tiempo estimado por ejercicio:
    • Ejercicio 1: 45-60 minutos.
    • Ejercicio 2: 60-75 minutos.
  • Consejo: Supervisar los diagramas de los alumnos antes de que escriban el código.
Etiquetas:

Comentarios

Publicar un comentario