Ejercicios Básicos de Programación Orientada a Objetos (POO) en Java – Parte 2

En esta segunda parte del artículo, continuaremos con ejercicios prácticos que profundizan en los conceptos de la Programación Orientada a Objetos (POO) en Java. Estos ejercicios están diseñados para fortalecer tu comprensión y habilidades en POO mediante la implementación de clases abstractas, interfaces y el uso de excepciones.

Ejercicio 6: Uso de Interfaces

1. Crea una interfaz Vehiculo con métodos arrancar, detener y velocidadActual.
2. Implementa esta interfaz en dos clases, Coche y Bicicleta.
3. Demuestra el uso de estas clases en un programa principal.

Solución:

interface Vehiculo {
    void arrancar();
    void detener();
    int velocidadActual();
}

class Coche implements Vehiculo {
    private int velocidad;

    @Override
    public void arrancar() {
        velocidad = 10;
        System.out.println("El coche ha arrancado");
    }

    @Override
    public void detener() {
        velocidad = 0;
        System.out.println("El coche se ha detenido");
    }

    @Override
    public int velocidadActual() {
        return velocidad;
    }
}

class Bicicleta implements Vehiculo {
    private int velocidad;

    @Override
    public void arrancar() {
        velocidad = 5;
        System.out.println("La bicicleta ha arrancado");
    }

    @Override
    public void detener() {
        velocidad = 0;
        System.out.println("La bicicleta se ha detenido");
    }

    @Override
    public int velocidadActual() {
        return velocidad;
    }
}

public class UsoDeInterfaces {
    public static void main(String[] args) {
        Vehiculo miCoche = new Coche();
        Vehiculo miBici = new Bicicleta();

        miCoche.arrancar();
        System.out.println("Velocidad actual del coche: " + miCoche.velocidadActual());
        miCoche.detener();

        miBici.arrancar();
        System.out.println("Velocidad actual de la bicicleta: " + miBici.velocidadActual());
        miBici.detener();
    }
}

Ejercicio 7: Manejo de Excepciones

1. Crea una clase Calculadora con un método dividir que recibe dos números y devuelve el resultado de la división.
2. Lanza una excepción personalizada si se intenta dividir por cero.
3. Maneja la excepción en el método principal.

Solución:

class DivisionPorCeroException extends Exception {
    public DivisionPorCeroException(String mensaje) {
        super(mensaje);
    }
}

class Calculadora {
    public double dividir(double numerador, double denominador) throws DivisionPorCeroException {
        if (denominador == 0) {
            throw new DivisionPorCeroException("No se puede dividir por cero");
        }
        return numerador / denominador;
    }
}

public class ManejoDeExcepciones {
    public static void main(String[] args) {
        Calculadora calc = new Calculadora();
        try {
            double resultado = calc.dividir(10, 0);
            System.out.println("El resultado es: " + resultado);
        } catch (DivisionPorCeroException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Ejercicio 8: Clase Abstracta Empleado

1. Crea una clase abstracta Empleado con atributos nombre y salarioBase, y un método abstracto calcularSalario.
2. Crea dos clases que extiendan de Empleado: EmpleadoFijo y EmpleadoPorHora.
3. Implementa el método calcularSalario en ambas clases.
4. Demuestra el uso de estas clases en un programa principal.

Solución:

abstract class Empleado {
    private String nombre;
    private double salarioBase;

    public Empleado(String nombre, double salarioBase) {
        this.nombre = nombre;
        this.salarioBase = salarioBase;
    }

    public String getNombre() {
        return nombre;
    }

    public double getSalarioBase() {
        return salarioBase;
    }

    public abstract double calcularSalario();
}

class EmpleadoFijo extends Empleado {
    public EmpleadoFijo(String nombre, double salarioBase) {
        super(nombre, salarioBase);
    }

    @Override
    public double calcularSalario() {
        return getSalarioBase();
    }
}

class EmpleadoPorHora extends Empleado {
    private int horasTrabajadas;
    private double tarifaPorHora;

    public EmpleadoPorHora(String nombre, double salarioBase, int horasTrabajadas, double tarifaPorHora) {
        super(nombre, salarioBase);
        this.horasTrabajadas = horasTrabajadas;
        this.tarifaPorHora = tarifaPorHora;
    }

    @Override
    public double calcularSalario() {
        return getSalarioBase() + (horasTrabajadas * tarifaPorHora);
    }
}

public class UsoDeClasesAbstractas {
    public static void main(String[] args) {
        Empleado empFijo = new EmpleadoFijo("Carlos", 3000);
        Empleado empPorHora = new EmpleadoPorHora("Ana", 1500, 40, 20);

        System.out.println("Salario de " + empFijo.getNombre() + ": " + empFijo.calcularSalario());
        System.out.println("Salario de " + empPorHora.getNombre() + ": " + empPorHora.calcularSalario());
    }
}

Ejercicio 9: Implementación de un Banco

1. Crea una clase CuentaBancaria con atributos numeroCuenta, saldo, y métodos para depositar y retirar.
2. Crea una clase Banco que gestione varias cuentas bancarias.
3. Implementa métodos para agregar cuentas, eliminar cuentas y mostrar todas las cuentas.
4. Demuestra el uso de estas clases en un programa principal.

Solución:

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

class CuentaBancaria {
    private String numeroCuenta;
    private double saldo;

    public CuentaBancaria(String numeroCuenta, double saldoInicial) {
        this.numeroCuenta = numeroCuenta;
        this.saldo = saldoInicial;
    }

    public String getNumeroCuenta() {
        return numeroCuenta;
    }

    public double getSaldo() {
        return saldo;
    }

    public void depositar(double cantidad) {
        saldo += cantidad;
    }

    public void retirar(double cantidad) {
        if (cantidad <= saldo) {
            saldo -= cantidad;
        } else {
            System.out.println("Fondos insuficientes");
        }
    }

    @Override
    public String toString() {
        return "CuentaBancaria{" +
                "numeroCuenta='" + numeroCuenta + '\'' +
                ", saldo=" + saldo +
                '}';
    }
}

class Banco {
    private List<CuentaBancaria> cuentas;

    public Banco() {
        cuentas = new ArrayList<>();
    }

    public void agregarCuenta(CuentaBancaria cuenta) {
        cuentas.add(cuenta);
    }

    public void eliminarCuenta(String numeroCuenta) {
        cuentas.removeIf(cuenta -> cuenta.getNumeroCuenta().equals(numeroCuenta));
    }

    public void mostrarCuentas() {
        for (CuentaBancaria cuenta : cuentas) {
            System.out.println(cuenta);
        }
    }

    public static void main(String[] args) {
        Banco banco = new Banco();
        CuentaBancaria cuenta1 = new CuentaBancaria("12345", 1000);
        CuentaBancaria cuenta2 = new CuentaBancaria("67890", 2000);

        banco.agregarCuenta(cuenta1);
        banco.agregarCuenta(cuenta2);

        banco.mostrarCuentas();

        cuenta1.depositar(500);
        cuenta2.retirar(1500);

        banco.mostrarCuentas();

        banco.eliminarCuenta("12345");
        banco.mostrarCuentas();
    }
}

Ejercicio 10: Sistema de Gestión de Inventario

1. Crea una clase Producto con atributos codigo, nombre, precio, y cantidad.
2. Implementa métodos para aumentarCantidad, reducirCantidad, y mostrarDetalles.
3. Crea una clase Inventario que gestione varios productos.
4. Implementa métodos para agregar productos, eliminar productos, buscar productos y mostrar todos los productos.
5. Demuestra el uso de estas clases en un programa principal.

Solución:

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

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

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

    public String getCodigo() {
        return codigo;
    }

    public String getNombre() {
        return nombre;
    }

    public double getPrecio() {
        return precio;
    }

    public int getCantidad() {
        return cantidad;
    }

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

    public void reducirCantidad(int cantidad) {
        if (this.cantidad >= cantidad) {
            this.cantidad -= cantidad;
        } else {
            System.out.println("Cantidad insuficiente en inventario

`` pero se reducirá a 0");
        }
    }

    public void mostrarDetalles() {
        System.out.println("Código: " + codigo);
        System.out.println("Nombre: " + nombre);
        System.out.println("Precio: " + precio);
        System.out.println("Cantidad: " + cantidad);
    }

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

class Inventario {
    private List<Producto> productos;

    public Inventario() {
        productos = new ArrayList<>();
    }

    public void agregarProducto(Producto producto) {
        productos.add(producto);
    }

    public void eliminarProducto(String codigo) {
        productos.removeIf(producto -> producto.getCodigo().equals(codigo));
    }

    public Producto buscarProducto(String codigo) {
        for (Producto producto : productos) {
            if (producto.getCodigo().equals(codigo)) {
                return producto;
            }
        }
        return null;
    }

    public void mostrarProductos() {
        for (Producto producto : productos) {
            System.out.println(producto);
        }
    }

    public static void main(String[] args) {
        Inventario inventario = new Inventario();
        Producto producto1 = new Producto("001", "Laptop", 1500.00, 10);
        Producto producto2 = new Producto("002", "Teléfono", 800.00, 20);

        inventario.agregarProducto(producto1);
        inventario.agregarProducto(producto2);

        inventario.mostrarProductos();

        Producto encontrado = inventario.buscarProducto("001");
        if (encontrado != null) {
            encontrado.mostrarDetalles();
        }

        inventario.eliminarProducto("002");
        inventario.mostrarProductos();
    }
}

Conclusión

Estos ejercicios avanzados de POO en Java proporcionan una comprensión más profunda de cómo utilizar las características avanzadas de POO para desarrollar software robusto y escalable. Practicar estos conceptos es crucial para mejorar tus habilidades de programación y preparar tus conocimientos para proyectos de mayor complejidad.