Objetos y estructuras de datos en Código Limpio
Abres una clase y todo son get y set. ¿Es un objeto o una bolsa de datos con métodos? Esa duda, que parece de matiz, decide lo fácil o difícil que será cambiar el código después.
Este artículo resume las ideas del capítulo 6 de «Clean Code», de Robert C. Martin, «Objects and Data Structures». Las explicaciones y los ejemplos son propios, no citas del libro. El código del artículo original se ha corregido (tenía un error que lanzaba una excepción) y se ha actualizado a Java 25. Forma parte de la guía de código limpio (clean code), con todos los principios y un ejemplo de cada uno.
Abstracción: enseña lo que significa, no cómo se guarda
Piensa en un mueble de televisión con un panel que tapa los cables. Ves la pantalla y los botones, que es lo que te interesa. Los cables, el router y los enchufes siguen ahí detrás, pero no tienes que saber cómo están colocados para ver la tele. Y si mañana cambias el router, el salón sigue igual.
Con los datos de una clase pasa lo mismo. Si un vehículo te dice cuántos litros de gasolina le quedan, te está enseñando un detalle: el combustible y la unidad en la que lo mide.
public interface Vehiculo {
double getLitrosDeGasolinaEnElDeposito();
}
¿Y si el vehículo es diésel, de GLP o eléctrico? ¿Y si se mide en galones? Quien lo use tendrá que conocer todos esos casos. Es mejor que te dé una idea abstracta, como el porcentaje de energía que le queda:
public interface Vehiculo {
double porcentajeDeEnergiaRestante();
}
Cada vehículo sabe calcularlo a su manera, y quien lo usa no se entera:
class CocheElectrico implements Vehiculo {
private final double kWhEnLaBateria;
private final double capacidadEnKWh;
CocheElectrico(double kWhEnLaBateria, double capacidadEnKWh) {
this.kWhEnLaBateria = kWhEnLaBateria;
this.capacidadEnKWh = capacidadEnKWh;
}
@Override
public double porcentajeDeEnergiaRestante() {
return 100 * kWhEnLaBateria / capacidadEnKWh;
}
}
Ojo: poner private a los atributos y generar un get para cada uno no es abstraer. Si los get enseñan los mismos datos que había detrás, el panel es de cristal.
Esconder la implementación depende también de los modificadores de acceso; en Kotlin, los tienes en modificadores de acceso en Kotlin.
Objetos frente a estructuras de datos
- Un objeto oculta sus datos tras abstracciones y ofrece funciones que trabajan con ellos. Le pides cosas:
forma.area(). - Una estructura de datos enseña sus datos y no tiene funciones con significado. Tú lees sus campos y haces el trabajo fuera:
area(forma).
Son opuestos, y por eso cada uno es bueno justo en lo que al otro le cuesta. El libro lo llama la antisimetría entre datos y objetos.
La solución orientada a objetos
Cada forma sabe calcular su área. El método area() es polimórfico: cada clase tiene su versión.
interface Forma {
double area();
}
class Rectangulo implements Forma {
private final double alto;
private final double ancho;
Rectangulo(double alto, double ancho) {
this.alto = alto;
this.ancho = ancho;
}
@Override
public double area() {
return alto * ancho;
}
}
class Cuadrado implements Forma {
private final double lado;
Cuadrado(double lado) {
this.lado = lado;
}
@Override
public double area() {
return lado * lado;
}
}
- Añadir una forma nueva es fácil. Un
Circuloes una clase más; nada de lo que ya existe cambia. - Añadir una función nueva es costoso. Si quieres
perimetro(), tienes que tocar la interfaz y todas las clases que la implementan.
La solución con estructuras de datos
Las formas solo guardan datos y una clase Geometria hace los cálculos. En el artículo original estaba así:
public class Geometria {
public double area(Object forma) throws Exception {
if (forma instanceof Cuadrado) {
Cuadrado cuadradoEjemplo = (Cuadrado) forma;
return cuadradoEjemplo.lado * cuadradoEjemplo.lado;
}
else if (forma instanceof Rectangulo) {
Cuadrado cuadradoEjemplo = (Cuadrado) forma; // error: convierte un Rectangulo en Cuadrado
return cuadradoEjemplo.lado * cuadradoEjemplo.lado;
}
throw new Exception();
}
}
Al ejecutarlo con un rectángulo, Java lanza ClassCastException: la segunda rama copia la primera y trata el rectángulo como un cuadrado. Es un error típico de copiar y pegar, y el compilador no lo detecta porque area acepta cualquier Object.
Desde Java 21 hay una forma mucho mejor de escribirlo: records (clases que solo guardan datos), una interfaz sellada (sealed, que fija qué tipos existen) y un switch con patrones:
sealed interface Forma permits Cuadrado, Rectangulo {}
record Cuadrado(double lado) implements Forma {}
record Rectangulo(double alto, double ancho) implements Forma {}
class Geometria {
static double area(Forma forma) {
return switch (forma) {
case Cuadrado c -> c.lado() * c.lado();
case Rectangulo r -> r.alto() * r.ancho();
};
}
static double perimetro(Forma forma) {
return switch (forma) {
case Cuadrado c -> 4 * c.lado();
case Rectangulo r -> 2 * (r.alto() + r.ancho());
};
}
}
- Añadir una función nueva es fácil.
perimetrose ha añadido sin tocarCuadradoniRectangulo. - Añadir una forma nueva es costoso. Hay que revisar todas las funciones de
Geometria.
La ventaja de la versión moderna es que ya no se te olvida ninguna: si añades Circulo a la lista de permits y no lo tratas, el código no compila:
Main.java:9: error: the switch expression does not cover all possible input values
Tampoco hace falta el throw new Exception() del final, porque el compilador sabe que no hay más casos.
Entonces, ¿qué uso?
Objetos
- Cuando lo que más cambia son los tipos: formas, medios de pago, proveedores
- Añadir un tipo no toca nada existente
- Añadir una operación toca todas las clases
Estructuras de datos
- Cuando lo que más cambia son las operaciones: cálculos, informes, exportaciones
- Añadir una operación no toca los datos
- Añadir un tipo toca todas las funciones
La idea de que todo tiene que ser un objeto es un mito. A veces lo que necesitas es una estructura de datos sencilla y unas funciones que trabajen con ella.
Este dilema tiene nombre fuera del libro: Philip Wadler lo llamó en 1998 el problema de la expresión (expression problem), la dificultad de poder añadir a la vez tipos nuevos y funciones nuevas sin modificar el código existente.
Lo que un objeto facilita, una estructura de datos lo complica. Y al revés.
Híbridos y DTO
El capítulo avisa de dos casos que conviene reconocer:
- Híbridos: clases que son mitad objeto y mitad estructura de datos. Tienen funciones con lógica de negocio, pero también enseñan sus datos con
getysetpara que otros trabajen con ellos. Reúnen lo peor de los dos mundos: cuesta añadir tanto tipos como funciones. - DTO (Data Transfer Object, objeto de transferencia de datos): estructuras de datos puras, sin comportamiento, que sirven para mover datos, por ejemplo entre la base de datos o una API y tu aplicación. Son útiles; el problema aparece cuando les vas metiendo reglas de negocio y acaban convertidas en híbridos.
Un record de Java es un buen DTO. Si te encuentras añadiéndole lógica de negocio, plantéate si debería ser un objeto de verdad. Cómo se usa un DTO en la frontera de una API, con un ejemplo ejecutado, lo tienes en qué es un DTO.
Qué es la Ley de Demeter
La Ley de Demeter es una regla de diseño orientado a objetos: un módulo no debería conocer las tripas de los objetos que usa, solo hablar con los que tiene más cerca.
Piensa en pagar en una tienda. El dependiente te dice el importe y tú pagas. No mete la mano en tu bolsillo, saca tu cartera y busca un billete. Si mañana pagas con el móvil, la tienda no tiene que cambiar nada.
La propusieron Karl Lieberherr, Ian Holland y Arthur Riel en el proyecto Demeter de la Northeastern University. Su página oficial la resume en «no hables con desconocidos» y la formula así, en su forma para objetos (traducción propia): dentro de un método, solo puedes enviar mensajes a:
- Los parámetros del método, incluido el propio objeto (
this). - Las partes inmediatas del objeto: sus atributos, los elementos de una colección que sea atributo suyo y lo que devuelvan los métodos del propio objeto.
- Los objetos creados dentro del método.
Por razones prácticas, también admite los objetos globales.
El choque de trenes
Path ruta = configuracion.getOpciones().getDirectorioDeSalida().getRutaAbsoluta();
Files.writeString(ruta.resolve("informe.txt"), contenido);
A esta cadena de llamadas el libro la llama choque de trenes (train wreck): parecen vagones enganchados. El código que la escribe sabe demasiado:
- que la configuración tiene opciones,
- que las opciones tienen un directorio de salida,
- y que ese directorio sabe calcular su ruta absoluta.
Sabe cómo desplazarse por tres objetos distintos. Si cambia cualquiera de ellos, este código se rompe aunque no tenga nada que ver.
Partir la cadena en tres líneas con variables intermedias se lee mejor, pero no arregla el problema: el código sigue conociendo toda la estructura.
La solución: pide lo que quieres
La pregunta útil es: ¿para qué querías la ruta? Para guardar un informe. Pues pídele eso a la configuración, y que cada objeto hable solo con su vecino:
class Configuracion {
private final Opciones opciones;
Configuracion(Opciones opciones) {
this.opciones = opciones;
}
Path guardarInforme(String nombre, String contenido) throws IOException {
return Files.writeString(opciones.rutaDeSalidaPara(nombre), contenido);
}
}
class Opciones {
private final DirectorioDeSalida directorioDeSalida;
Opciones(DirectorioDeSalida directorioDeSalida) {
this.directorioDeSalida = directorioDeSalida;
}
Path rutaDeSalidaPara(String nombre) {
return directorioDeSalida.rutaPara(nombre);
}
}
class DirectorioDeSalida {
private final Path ruta;
DirectorioDeSalida(Path ruta) {
this.ruta = ruta;
}
Path rutaPara(String nombre) {
return ruta.toAbsolutePath().resolve(nombre);
}
}
Y quien lo usa solo escribe:
configuracion.guardarInforme("informe.txt", contenido);
configuracion, y cada objeto pasa el encargo a su vecino.Esta idea se conoce también como Tell, Don’t Ask («dile, no le preguntes»), de Andy Hunt y Dave Thomas. Martin Fowler matiza que llevarla al extremo y eliminar todos los métodos de consulta complica el código: a veces pedir un dato es lo más sencillo.
Con estructuras de datos, la ley no aplica
Si Opciones y DirectorioDeSalida fueran estructuras de datos, encadenar sería normal, porque su razón de ser es enseñar lo que contienen:
record DirectorioDeSalida(Path ruta) {}
record Opciones(DirectorioDeSalida directorioDeSalida) {}
record Configuracion(Opciones opciones) {}
Path ruta = configuracion.opciones().directorioDeSalida().ruta();
La Ley de Demeter protege a los objetos, que esconden su estructura. Una estructura de datos no tiene nada que esconder. El problema de verdad son los híbridos: si no sabes si una clase es objeto o datos, tampoco sabrás si puedes encadenar.
Y cuando programas con IA
Este criterio es propio del enfoque IA Limpia, no del libro. Un asistente de IA tiende a resolver lo que le pides por el camino más corto: si necesita un dato, lo saca encadenando get, y si una clase de datos necesita una regla, se la añade ahí mismo. El resultado funciona, pero va llenando el código de choques de trenes e híbridos.
Al revisar lo que genera, busca dos cosas:
- Cadenas de llamadas que atraviesan varios objetos. Pregúntate para qué quería ese dato y pídeselo al objeto.
- Records o DTO a los que les ha crecido lógica de negocio.
También puedes decírselo de antemano en las instrucciones del proyecto: qué clases son objetos y cuáles son estructuras de datos.
Siguiente paso
Busca en tu proyecto una línea con tres o más get encadenados. Pregúntate para qué se quería el dato del final y prueba a mover ese trabajo al primer objeto de la cadena.
Sigue con la serie: clases en código limpio trata la responsabilidad única y la cohesión, y funciones en código limpio, cómo mantenerlas pequeñas.
Fuentes
- Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship (Prentice Hall, 2008), capítulo 6, «Objects and Data Structures». Las ideas se explican con palabras propias; no hay citas literales del libro.
- Ley de Demeter: formulación para objetos y formulación general en la web del proyecto Demeter (Northeastern University), consultadas en noviembre de 2026. Artículos originales: K. Lieberherr, I. Holland y A. Riel, «Object-Oriented Programming: An Objective Sense of Style», OOPSLA 1988; y K. Lieberherr e I. Holland, «Assuring Good Style for Object-Oriented Programs», IEEE Software, 1989.
- Philip Wadler, «The Expression Problem», 12 de noviembre de 1998.
- Martin Fowler, «TellDontAsk», 2013.
- Todos los ejemplos de Java se han ejecutado con OpenJDK 25.0.5 (imagen oficial
eclipse-temurin:25), incluido el código original, que lanzaClassCastException, y el error de compilación al añadirCirculosin tratarlo en elswitch.