Entornos de Desarrollo - Unidad 5 - Sesión 7: Implementación de Métodos y Test de Clases

Objetivos de la sesión

Aprender a implementar métodos en clases para realizar operaciones específicas.
Introducir el concepto de pruebas unitarias en programación orientada a objetos.
Crear y ejecutar pruebas unitarias para verificar la correcta implementación de los métodos.
Aplicar técnicas de depuración para solucionar errores en el código.

Estructura de la sesión

1. Introducción teórica: Métodos y pruebas unitarias (20 minutos)

Implementación de métodos:

Métodos: Son bloques de código dentro de una clase que realizan una acción o devuelven un valor.
- Sintaxis básica:
```
public tipoDeRetorno nombreDelMetodo(parametros) {
    // cuerpo del método
}
```
- Tipos de métodos:
  - Métodos sin valor de retorno:
    Realizan una acción pero no devuelven ningún valor.
```
public void imprimirSaludo() {
    System.out.println("Hola Mundo");
}
```
  - Métodos con valor de retorno:
    Devuelven un valor de un tipo específico.
```
public int sumar(int a, int b) {
    return a + b;
}
```

Pruebas Unitarias:

Definición: Son pruebas que verifican el comportamiento de métodos específicos en clases.
Objetivo: Asegurar que cada unidad de código (método) funcione de acuerdo a lo esperado.

Herramientas para realizar pruebas unitarias:

JUnit: Es una de las herramientas más populares para realizar pruebas unitarias en Java.

Estructura básica de una prueba unitaria con JUnit:

@Test
public void testSumar() {
    Calculadora calc = new Calculadora();
    int resultado = calc.sumar(3, 2);
    assertEquals(5, resultado);
}

Tipos de pruebas:

Prueba positiva: Se verifica que el método devuelve el resultado esperado cuando los datos son correctos.
Prueba negativa: Se verifica que el método maneja correctamente las entradas incorrectas o errores.

2. Ejercicio guiado: Implementación de métodos y pruebas unitarias (40 minutos)

Descripción:
Vamos a implementar un método que calcule el área de un rectángulo y luego crearemos pruebas unitarias para asegurarnos de que el método funcione correctamente.

Paso 1: Crear clase Rectángulo

Los estudiantes crearán una clase Rectangulo que tendrá los siguientes atributos:

base (int): la base del rectángulo.
altura (int): la altura del rectángulo.

Y un método:

calcularArea(): que devuelve el área del rectángulo.

Código base para Rectángulo:

public class Rectangulo {
    private int base;
    private int altura;

    public Rectangulo(int base, int altura) {
        this.base = base;
        this.altura = altura;
    }

    public int calcularArea() {
        return base * altura;
    }
}

Paso 2: Crear pruebas unitarias con JUnit

Los estudiantes escribirán una prueba unitaria para verificar que el método calcularArea() funciona correctamente.

Código para prueba unitaria (JUnit):

import static org.junit.Assert.assertEquals;
import org.junit.Test;

public class RectanguloTest {

    @Test
    public void testCalcularArea() {
        Rectangulo rect = new Rectangulo(5, 10);
        int resultado = rect.calcularArea();
        assertEquals(50, resultado);  // Verifica que el área sea 5 * 10 = 50
    }

    @Test
    public void testAreaConBaseCero() {
        Rectangulo rect = new Rectangulo(0, 10);
        int resultado = rect.calcularArea();
        assertEquals(0, resultado);  // Verifica que el área sea 0 si la base es 0
    }

    @Test
    public void testAreaConAlturaCero() {
        Rectangulo rect = new Rectangulo(5, 0);
        int resultado = rect.calcularArea();
        assertEquals(0, resultado);  // Verifica que el área sea 0 si la altura es 0
    }
}

Paso 3: Ejecutar las pruebas

Los estudiantes deben instalar JUnit en su entorno de desarrollo (en Eclipse o IntelliJ IDEA).
Ejecutar las pruebas unitarias para comprobar que todas las pruebas pasen correctamente.

3. Actividad en grupo: Implementar un sistema de cálculo de notas (40 minutos)

Descripción:
Los estudiantes en grupos implementarán un sistema para calcular el promedio de las notas de estudiantes y crearán pruebas unitarias para comprobar su correcto funcionamiento.

Requisitos del sistema:

Clase Estudiante:
- Atributos: nombre (String), notas (array de enteros).
- Método: calcularPromedio() que devuelve el promedio de las notas.
Clase Principal:
- Crear varios objetos de la clase Estudiante, asignarles notas y calcular su promedio.

Paso 1: Crear la clase Estudiante

Código base para Estudiante:

public class Estudiante {
    private String nombre;
    private int[] notas;

    public Estudiante(String nombre, int[] notas) {
        this.nombre = nombre;
        this.notas = notas;
    }

    public double calcularPromedio() {
        int suma = 0;
        for (int nota : notas) {
            suma += nota;
        }
        return suma / (double) notas.length;
    }
}

Paso 2: Crear las pruebas unitarias

Los estudiantes escribirán pruebas para verificar el cálculo del promedio.

Código para prueba unitaria (JUnit):

import static org.junit.Assert.assertEquals;
import org.junit.Test;

public class EstudianteTest {

    @Test
    public void testCalcularPromedio() {
        Estudiante est = new Estudiante("Juan", new int[] { 7, 8, 9 });
        double resultado = est.calcularPromedio();
        assertEquals(8.0, resultado, 0.01);  // Promedio debe ser 8.0
    }

    @Test
    public void testPromedioConUnaNota() {
        Estudiante est = new Estudiante("María", new int[] { 10 });
        double resultado = est.calcularPromedio();
        assertEquals(10.0, resultado, 0.01);  // Promedio debe ser 10.0
    }
}

Paso 3: Ejecutar las pruebas unitarias

Ejecutar las pruebas unitarias para comprobar que el método calcularPromedio() funciona correctamente.

4. Resolución y cierre (15 minutos)

Revisión de ejercicios:
El profesor puede ayudar a los estudiantes con errores comunes en la implementación de los métodos y las pruebas unitarias.
Reflexión:
- ¿Qué desafíos encontraron al escribir pruebas unitarias?
- ¿Qué se puede mejorar en el diseño de las clases que implementaron?
- ¿Cómo mejorarían las pruebas para asegurar más casos (notas negativas, notas con decimales, etc.)?
Avance para la siguiente sesión:
- Introducción a colecciones en Java, como listas y mapas.

Apuntes para el profesor

Solución del ejercicio guiado:

Código para la clase Rectangulo:

public class Rectangulo {
    private int base;
    private int altura;

    public Rectangulo(int base, int altura) {
        this.base = base;
        this.altura = altura;
    }

    public int calcularArea() {
        return base * altura;
    }
}

Código para las pruebas unitarias:

import static org.junit.Assert.assertEquals;
import org.junit.Test;

public class RectanguloTest {

    @Test
    public void testCalcularArea() {
        Rectangulo rect = new Rectangulo(5, 10);
        int resultado = rect.calcularArea();
        assertEquals(50, resultado);
    }

    @Test
    public void testAreaConBaseCero() {
        Rectangulo rect = new Rectangulo(0, 10);
        int resultado = rect.calcularArea();
        assertEquals(0, resultado);
    }

    @Test
    public void testAreaConAlturaCero() {
        Rectangulo rect = new Rectangulo(5, 0);
        int resultado = rect.calcularArea();
        assertEquals(0, resultado);
    }
}

Material necesario:

Entorno de desarrollo configurado con JUnit.
Código base para realizar las pruebas.

VelvetBit

Buscar este blog