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.

person encoding in laptop
Photo by Lukas on Pexels.com
error: Content is protected !!

Descubre más desde InfoGonzalez - Blog de formador e informático

Suscríbete ahora para seguir leyendo y obtener acceso al archivo completo.

Seguir leyendo

Este sitio web utiliza cookies, si necesitas más información puedes visitar nuestra política de privacidad    Ver
Privacidad
Creative Commons License
Except where otherwise noted, the content on this site is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.