Ejercicio resuelto: clases y objetos con un monedero en Java

La solución separa dos responsabilidades. La clase Monedero protege su estado y aplica las reglas del negocio; el método main solo lee líneas, localiza el monedero del titular y escribe el resultado. Esta división es exactamente lo que se pretende ilustrar con un primer ejercicio de clases y objetos.

El saldo se guarda como int en céntimos. Con enteros todas las comparaciones son exactas y el límite de 15000 se puede probar con igualdad sin miedo a errores de redondeo.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

public class Main {

    static class Monedero {
        private static final int MAXIMO = 15000;

        private final String titular;
        private int saldo;

        Monedero(String titular) {
            this.titular = titular;
            this.saldo = 0;
        }

        String getTitular() {
            return titular;
        }

        int getSaldo() {
            return saldo;
        }

        String recargar(int centimos) {
            if (centimos <= 0) {
                return "INVALIDO";
            }
            if (saldo + centimos > MAXIMO) {
                return "LIMITE";
            }
            saldo += centimos;
            return "OK";
        }

        String pagar(int centimos) {
            if (centimos <= 0) {
                return "INVALIDO";
            }
            if (centimos > saldo) {
                return "INSUFICIENTE";
            }
            saldo -= centimos;
            return "OK";
        }

        String saldoEnEuros() {
            return String.format("%d.%02d", saldo / 100, saldo % 100);
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String primera = in.readLine();
        if (primera == null || primera.isBlank()) {
            return;
        }
        int n = Integer.parseInt(primera.trim());
        Map<String, Monedero> monederos = new HashMap<>();
        StringBuilder salida = new StringBuilder();

        for (int i = 0; i < n; i++) {
            String linea = in.readLine();
            if (linea == null) {
                break;
            }
            String[] partes = linea.trim().split("\\s+");
            String titular = partes[0];
            String operacion = partes[1];
            int importe = Integer.parseInt(partes[2]);

            Monedero m = monederos.computeIfAbsent(titular, Monedero::new);
            String resultado;
            if (operacion.equals("RECARGA")) {
                resultado = m.recargar(importe);
            } else {
                resultado = m.pagar(importe);
            }
            salida.append(resultado).append(' ')
                  .append(m.getTitular()).append(' ')
                  .append(m.saldoEnEuros()).append('\n');
        }
        System.out.print(salida);
    }
}

La clase Monedero. Los atributos titular y saldo son privados y la constante MAXIMO vale 15000. El constructor fija el saldo en 0. Fuera de la clase no hay forma de escribir en saldo: solo recargar y pagar lo modifican, y ambos validan antes de tocarlo. Esa es la encapsulación en la práctica: el invariante «0 ≤ saldo ≤ 15000» se mantiene porque una única clase lo vigila.

Orden de las comprobaciones. En recargar se comprueba primero centimos <= 0 y después saldo + centimos > MAXIMO; en pagar, el importe no positivo y luego centimos > saldo. El orden importa: un importe negativo debe dar INVALIDO aunque además fuese incoherente con otra regla. Solo la rama final, la aceptada, ejecuta saldo += centimos o saldo -= centimos, de modo que una operación rechazada deja el saldo intacto.

El main. El HashMap asocia cada nombre con su objeto. computeIfAbsent(titular, Monedero::new) crea el monedero con saldo 0 la primera vez y devuelve el existente las siguientes, así que cada titular tiene un objeto distinto e independiente. Cada línea se separa con split sobre espacios y el resultado se acumula en un StringBuilder para imprimir al final. Si n es 0, el bucle no se ejecuta y no se escribe nada.

Formato del saldo. saldoEnEuros usa saldo / 100 y saldo % 100 con %02d, de modo que 50 céntimos se escriben 0.50 y 15000 se escribe 150.00. Al no pasar nunca por un double, no hay redondeos que expliquen resultados sorprendentes.

Casos de prueba. El primer test, el del enunciado, mezcla recargas y pagos de dos titulares y comprueba que sus saldos no se mezclan. El segundo ejerce las tres razones de rechazo (importe cero, importe negativo y pago superior al saldo). El tercero, «Límites exactos de saldo», recarga hasta llegar exactamente a 150.00, que se acepta, y comprueba que 1 céntimo más se rechaza con LIMITE sin alterar el saldo. El cuarto cubre el caso de entrada con 0 operaciones, que no produce ninguna salida, y el quinto una sola operación de un titular nuevo.