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
- Crea una interfaz
Vehiculo
con métodosarrancar
,detener
yvelocidadActual
. - Implementa esta interfaz en dos clases,
Coche
yBicicleta
. - 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
- Crea una clase
Calculadora
con un métododividir
que recibe dos números y devuelve el resultado de la división. - Lanza una excepción personalizada si se intenta dividir por cero.
- 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
- Crea una clase abstracta
Empleado
con atributosnombre
ysalarioBase
, y un método abstractocalcularSalario
. - Crea dos clases que extiendan de
Empleado
:EmpleadoFijo
yEmpleadoPorHora
. - Implementa el método
calcularSalario
en ambas clases. - 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
- Crea una clase
CuentaBancaria
con atributosnumeroCuenta
,saldo
, y métodos paradepositar
yretirar
. - Crea una clase
Banco
que gestione varias cuentas bancarias. - Implementa métodos para agregar cuentas, eliminar cuentas y mostrar todas las cuentas.
- 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
- Crea una clase
Producto
con atributoscodigo
,nombre
,precio
, ycantidad
. - Implementa métodos para
aumentarCantidad
,reducirCantidad
, ymostrarDetalles
. - Crea una clase
Inventario
que gestione varios productos. - Implementa métodos para agregar productos, eliminar productos, buscar productos y mostrar todos los productos.
- 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.
Gracias por visitar mi blog de informática, mi nombre es Tomás y soy formador y desarrollador web. Si quiere usted dejarme alguna sugerencia, ayuda o quiere un servicio de formación estoy escuchando ofertas en tomas.gonzalez@infogonzalez.com, en Facebook a https://www.facebook.com/Infogonzalez estoy deseando escucharle. Su duda o sugerencia NO molesta.