Saltar a contenido

Semana 5 - Métodos Generales de una Clase

Construcción de la Lógica de Negocio de una Aplicación

La lógica de negocio es el conjunto de reglas, procesos y operaciones que definen cómo funciona una aplicación. En la programación orientada a objetos, esta lógica se implementa principalmente a través de los métodos de las clases.

Principios para Construir la Lógica de Negocio

  • Separación de responsabilidades: Cada clase debe tener una única responsabilidad bien definida. -. Encapsulamiento: Los detalles de implementación deben ocultarse y solo exponer lo necesario mediante interfaces públicas.
  • Cohesión: Los métodos de una clase deben estar estrechamente relacionados entre sí.

Ejemplo Práctico

public class GestorVentas {
    private List<Producto> inventario;
    private List<Venta> ventas;

    public GestorVentas() {
        this.inventario = new ArrayList<>();
        this.ventas = new ArrayList<>();
    }

    // Método que implementa lógica de negocio para registrar una venta
    public boolean registrarVenta(Producto producto, int cantidad) {
        // Verificar disponibilidad en inventario
        if (!hayStockDisponible(producto, cantidad)) {
            return false;
        }

        // Actualizar inventario
        actualizarInventario(producto, cantidad);

        // Registrar la venta
        Venta nuevaVenta = new Venta(producto, cantidad, new Date());
        ventas.add(nuevaVenta);

        // Generar factura
        generarFactura(nuevaVenta);

        return true;
    }

    private boolean hayStockDisponible(Producto producto, int cantidad) {
        // Lógica para verificar disponibilidad
        return true; // Simplificado para el ejemplo
    }

    private void actualizarInventario(Producto producto, int cantidad) {
        // Lógica para actualizar inventario
    }

    private void generarFactura(Venta venta) {
        // Lógica para generar factura
    }
}

Uso del Operador this

El operador this es una referencia al objeto actual y se utiliza principalmente para:

  1. Diferenciar entre variables de instancia y parámetros con el mismo nombre
  2. Invocar constructores de la misma clase
  3. Retornar la instancia actual para permitir encadenamiento de métodos
  4. Pasar la referencia del objeto actual a otro método

Ejemplos de Uso

public class Empleado {
    private String nombre;
    private double salario;
    private int edad;

    // Constructor básico
    public Empleado() {
        this("Sin nombre", 0, 0); // Invoca al constructor con parámetros
    }

    // Constructor con parámetros
    public Empleado(String nombre, double salario, int edad) {
        this.nombre = nombre;     // Diferencia entre variable de instancia y parámetro
        this.salario = salario;   // Diferencia entre variable de instancia y parámetro
        this.edad = edad;         // Diferencia entre variable de instancia y parámetro
    }

    // Método que retorna this para permitir encadenamiento
    public Empleado aumentarSalario(double porcentaje) {
        this.salario += this.salario * (porcentaje / 100);
        return this; // Retorna la instancia actual
    }

    // Método que pasa this como referencia
    public void registrarEnSistema(SistemaRRHH sistema) {
        sistema.agregarEmpleado(this); // Pasa la referencia del objeto actual
    }

    // Getters y setters
    public String getNombre() {
        return this.nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

Ejemplo de Encadenamiento de Métodos

Empleado emp = new Empleado();
emp.setNombre("Juan")
   .aumentarSalario(10)
   .registrarEnSistema(sistema);

Sobrecarga de Métodos

La sobrecarga de métodos permite definir múltiples métodos con el mismo nombre pero con diferentes parámetros. Esto mejora la legibilidad y usabilidad del código.

Reglas para la Sobrecarga de Métodos

  • Mismo nombre de método
  • Diferente lista de parámetros (diferente tipo, número o ambos)
  • El tipo de retorno puede ser igual o diferente (no es suficiente para distinguir sobrecargas)

Ejemplo de Sobrecarga

public class Calculadora {
    // Sobrecarga para sumar dos enteros
    public int sumar(int a, int b) {
        return a + b;
    }

    // Sobrecarga para sumar tres enteros
    public int sumar(int a, int b, int c) {
        return a + b + c;
    }

    // Sobrecarga para sumar dos números decimales
    public double sumar(double a, double b) {
        return a + b;
    }

    // Sobrecarga para concatenar dos cadenas
    public String sumar(String a, String b) {
        return a + b;
    }
}

Uso de la Sobrecarga

Calculadora calc = new Calculadora();

int resultado1 = calc.sumar(5, 3);           // Llama a sumar(int, int)
int resultado2 = calc.sumar(5, 3, 2);        // Llama a sumar(int, int, int)
double resultado3 = calc.sumar(5.5, 3.5);    // Llama a sumar(double, double)
String resultado4 = calc.sumar("Hola ", "Mundo"); // Llama a sumar(String, String)

Ejercicio: Tienda de Productos

Descripción del Problema

Desarrolla un sistema básico para una tienda de productos que permita: - Registrar productos en el inventario. - Vender productos. - Consultar la disponibilidad de un producto. - Mostrar el total de ventas realizadas.

Clases a Implementar

  • Clase Producto: Representa un producto con atributos como nombre, precio y cantidad en stock.
  • Clase Tienda: Contiene la lógica de negocio principal, como registrar productos, vender productos y calcular ventas totales.

Código Fuente

1. Clase Producto

public class Producto {
    private String nombre;
    private double precio;
    private int cantidad;

    // Constructor
    public Producto(String nombre, double precio, int cantidad) {
        this.nombre = nombre;
        this.precio = precio;
        this.cantidad = cantidad;
    }

    // Getters y Setters
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }

    // Método para reducir la cantidad en stock
    public void reducirStock(int cantidadVendida) {
        if (cantidad >= cantidadVendida) {
            this.cantidad -= cantidadVendida;
        } else {
            System.out.println("No hay suficiente stock disponible.");
        }
    }

    // Método para verificar disponibilidad
    public boolean estaDisponible(int cantidadDeseada) {
        return this.cantidad >= cantidadDeseada;
    }

    @Override
    public String toString() {
        return "Producto{" +
                "nombre='" + nombre + '\'' +
                ", precio=" + precio +
                ", cantidad=" + cantidad +
                '}';
    }
}

2. Clase Tienda

import java.util.ArrayList;
import java.util.List;

public class Tienda {
    private List<Producto> inventario;
    private double ventasTotales;

    // Constructor
    public Tienda() {
        this.inventario = new ArrayList<>();
        this.ventasTotales = 0.0;
    }

    // Método para agregar un producto al inventario
    public void agregarProducto(Producto producto) {
        inventario.add(producto);
        System.out.println("Producto agregado: " + producto.getNombre());
    }

    // Método para vender un producto
    public void venderProducto(String nombreProducto, int cantidad) {
        for (Producto producto : inventario) {
            if (producto.getNombre().equalsIgnoreCase(nombreProducto)) {
                if (producto.estaDisponible(cantidad)) {
                    double venta = producto.getPrecio() * cantidad;
                    producto.reducirStock(cantidad);
                    ventasTotales += venta;
                    System.out.println("Venta realizada: " + cantidad + " unidades de " + nombreProducto);
                    return;
                } else {
                    System.out.println("No hay suficiente stock de " + nombreProducto);
                    return;
                }
            }
        }
        System.out.println("Producto no encontrado: " + nombreProducto);
    }

    // Método para consultar disponibilidad
    public void consultarDisponibilidad(String nombreProducto) {
        for (Producto producto : inventario) {
            if (producto.getNombre().equalsIgnoreCase(nombreProducto)) {
                System.out.println("Disponibilidad de " + nombreProducto + ": " + producto.getCantidad() + " unidades");
                return;
            }
        }
        System.out.println("Producto no encontrado: " + nombreProducto);
    }

    // Método para mostrar las ventas totales
    public void mostrarVentasTotales() {
        System.out.println("Ventas totales: $" + ventasTotales);
    }
}

3. Programa Principal

public class Main {
    public static void main(String[] args) {
        // Crear una tienda
        Tienda tienda = new Tienda();

        // Agregar productos al inventario
        tienda.agregarProducto(new Producto("Laptop", 1500.0, 10));
        tienda.agregarProducto(new Producto("Mouse", 25.0, 50));

        // Consultar disponibilidad
        tienda.consultarDisponibilidad("Laptop");

        // Realizar una venta
        tienda.venderProducto("Laptop", 2);
        tienda.venderProducto("Mouse", 10);

        // Consultar disponibilidad después de la venta
        tienda.consultarDisponibilidad("Laptop");
        tienda.consultarDisponibilidad("Mouse");

        // Mostrar ventas totales
        tienda.mostrarVentasTotales();
    }
}

Salida Esperada

Producto agregado: Laptop
Producto agregado: Mouse
Disponibilidad de Laptop: 10 unidades
Venta realizada: 2 unidades de Laptop
Venta realizada: 10 unidades de Mouse
Disponibilidad de Laptop: 8 unidades
Disponibilidad de Mouse: 40 unidades
Ventas totales: $3250.0

Explicación del Ejercicio

Clase Producto:

  • Representa un producto con atributos como nombre, precio y cantidad.
  • Incluye métodos para reducir el stock (reducirStock) y verificar disponibilidad (estaDisponible).
  • Usa encapsulamiento con getters y setters.

Clase Tienda:

  • Contiene la lógica de negocio principal.
  • Gestiona el inventario (lista de productos) y las ventas.
  • Implementa reglas de negocio simples, como verificar disponibilidad antes de vender y actualizar las ventas totales.

Programa Principal:

  • Demuestra cómo interactuar con las clases Producto y Tienda.
  • Muestra cómo agregar productos, realizar ventas, consultar disponibilidad y mostrar ventas totales.

Actividad Práctica: Implementación de Lógica de Negocio

En esta actividad, pondrás en práctica los conceptos aprendidos sobre métodos de clase, uso del operador this y sobrecarga de métodos para implementar la lógica de negocio de una aplicación.

Descripción del Problema

Desarrolla un sistema de gestión para una biblioteca que permita administrar libros, usuarios y préstamos. El sistema debe implementar las siguientes funcionalidades básicas:

  • Registrar nuevos libros en el inventario
  • Registrar nuevos usuarios
  • Realizar préstamos de libros a usuarios
  • Registrar devoluciones de libros
  • Consultar disponibilidad de libros
  • Consultar historial de préstamos de un usuario

Clases a Implementar

1. Clase Libro

public class Libro {
    // Atributos: título, autor, ISBN, año de publicación, disponible (boolean)

    // Constructor(es)

    // Métodos getter y setter

    // Método para marcar como prestado

    // Método para marcar como disponible

    // Método toString() para mostrar información del libro
}

2. Clase Usuario

public class Usuario {
    // Atributos: id, nombre, email, lista de préstamos actuales

    // Constructor(es)

    // Métodos getter y setter

    // Método para agregar un préstamo a la lista

    // Método para eliminar un préstamo de la lista

    // Método toString() para mostrar información del usuario
}

3. Clase Prestamo

public class Prestamo {
    // Atributos: libro, usuario, fecha de préstamo, fecha de devolución prevista

    // Constructor(es)

    // Métodos getter y setter

    // Método para calcular días de retraso

    // Método toString() para mostrar información del préstamo
}

4. Clase Biblioteca (Lógica de Negocio Principal)

public class Biblioteca {
    // Atributos: lista de libros, lista de usuarios, lista de préstamos

    // Constructor

    // Método para agregar un libro al inventario (con sobrecarga)

    // Método para registrar un usuario (con sobrecarga)

    // Método para realizar un préstamo

    // Método para registrar una devolución

    // Método para buscar libros (con sobrecarga para diferentes criterios)

    // Método para consultar préstamos de un usuario

    // Método para generar informes
}

Entregables

  • Repositorio GitHub (Código fuente de las clases implementadas)
  • Un programa principal (clase con método main) que demuestre el funcionamiento del sistema
  • Documentación breve explicando las decisiones de diseño tomadas (README:md)