Mapa de POO moderna en Java

La POO moderna no es solo clases y herencia

La programación orientada a objetos en Java empieza con clases y objetos, pero no termina ahí. En código profesional también aparecen contratos de igualdad, ordenación, excepciones de dominio, generics, records, sealed classes y pattern matching.

Pensarlo todo como "crear clases" suele llevar a diseños rígidos. La clave está en decidir qué papel cumple cada construcción.

public final class Cuenta {
    private final String iban;
    private long saldoCentimos;

    public Cuenta(String iban) {
        this.iban = iban;
    }

    public void ingresar(long centimos) {
        if (centimos <= 0) {
            throw new IllegalArgumentException("Importe inválido");
        }
        saldoCentimos += centimos;
    }
}

Este ejemplo ya muestra varias decisiones de diseño orientado a objetos: estado privado, invariantes, constructor, método de dominio y error cuando se intenta romper una regla.

Una clase no debería ser una bolsa de datos con getters. Debería proteger invariantes y ofrecer operaciones que tengan sentido para el dominio.

Cuatro bloques que conviene separar mentalmente

El primer bloque es modelo e invariantes. Aquí entran clases, objetos, constructores, encapsulación, static e inmutabilidad. El objetivo es representar entidades del dominio sin exponer detalles internos.

public final class Producto {
    private final String sku;
    private final String nombre;

    public Producto(String sku, String nombre) {
        this.sku = sku;
        this.nombre = nombre;
    }

    public String sku() {
        return sku;
    }
}

El segundo bloque es jerarquía y sustitución. Aquí aparecen herencia, clases abstractas, interfaces y polimorfismo. Sirven cuando varios tipos comparten una capacidad o una familia conceptual.

interface Descuento {
    long aplicar(long precioCentimos);
}

final class DescuentoPorcentaje implements Descuento {
    private final int porcentaje;

    DescuentoPorcentaje(int porcentaje) {
        this.porcentaje = porcentaje;
    }

    @Override
    public long aplicar(long precioCentimos) {
        return precioCentimos - (precioCentimos * porcentaje / 100);
    }
}

El tercer bloque es contratos y errores. Java usa métodos como equals, hashCode, toString, Comparable y Comparator para que tus objetos funcionen bien dentro de colecciones, logs, ordenaciones y mapas.

record Cliente(String id, String email) implements Comparable<Cliente> {
    @Override
    public int compareTo(Cliente other) {
        return this.email.compareToIgnoreCase(other.email);
    }
}

Los records generan equals, hashCode y toString de forma coherente, pero eso no elimina la necesidad de entender el contrato. Si un objeto va a vivir dentro de un HashSet o como clave de un HashMap, la igualdad importa.

Tipos modernos para modelar mejor

El cuarto bloque es expresividad moderna. Java permite combinar generics, records, sealed classes y pattern matching para crear modelos más precisos sin recurrir a jerarquías enormes.

sealed interface Resultado permits Exito, Fallo { }

record Exito(String mensaje) implements Resultado { }

record Fallo(String codigo, String detalle) implements Resultado { }

static String describir(Resultado resultado) {
    return switch (resultado) {
        case Exito exito -> "OK: " + exito.mensaje();
        case Fallo fallo -> "ERROR " + fallo.codigo() + ": " + fallo.detalle();
    };
}

Una sealed interface declara todas las variantes permitidas. El switch puede comprobar la exhaustividad porque conoce toda la familia de tipos. Esto es útil para estados de negocio, resultados de operaciones, comandos o eventos de dominio.

public final class Repositorio<T> {
    private final List<T> elementos = new ArrayList<>();

    public void guardar(T elemento) {
        elementos.add(elemento);
    }

    public List<T> listar() {
        return List.copyOf(elementos);
    }
}

Los generics permiten reutilizar una estructura sin perder seguridad de tipos. La idea no es hacer el código más abstracto porque sí, sino evitar duplicación cuando el comportamiento es común y el tipo concreto cambia.

La POO moderna en Java funciona mejor cuando eliges la pieza por intención: clase para invariantes, interfaz para capacidades, record para datos inmutables, sealed para variantes cerradas y generic para reutilización tipada.