Abstracción

Actualizado el 15 de noviembre de 2026

Sigla A
Aspecto «Diseño de paquetes»
Se mide en paquete
Tipo de valor proporción entre 0 y 1 (Stau Metro la muestra como decimal, no como porcentaje)
Dirección informativa: ni alto ni bajo es mejor
Origen Robert C. Martin, 1994
Familia «Métricas de paquetes de Martin»
Stau Metro Abstractness

En pocas palabras

Dice qué parte de un paquete son contratos (interfaces y clases abstractas) y qué parte son implementaciones concretas. Un 0 es un paquete que solo tiene clases listas para usar; un 1, uno que solo define tipos que otros implementan. Por sí sola no es buena ni mala: cobra sentido al compararla con lo estable que es el paquete.

Qué mide

El grado en que un paquete se puede extender sin modificarlo. Quien depende de una interfaz puede recibir una implementación nueva sin que el paquete que la define cambie; quien depende de una clase concreta está atado a ella.

La idea de Martin es que la abstracción debe acompañar a la estabilidad: un paquete del que dependen muchos otros es caro de cambiar, así que conviene que sea abstracto, para que se pueda ampliar sin tocarlo. Esa relación es la que recoge la «distancia a la secuencia principal», que combina esta métrica con la «inestabilidad».

Cómo se calcula

A=NaNcA = \frac{N_a}{N_c}

donde NcN_c es el número de clases del paquete y NaN_a el de las que son abstractas, contando las interfaces como abstractas. Vale entre 0 y 1. Un paquete sin clases no tiene valor.

Martin la definió sobre categorías de clases, grupos de clases muy cohesionadas, como el número de clases abstractas de la categoría dividido entre su total de clases; en Java el equivalente habitual es el paquete, y una interfaz es la forma más pura de clase abstracta.

Ejemplo

Un paquete shop.payment con estos tipos:

// PaymentGateway.java
package shop.payment;
public interface PaymentGateway { void charge(long cents); }          // abstracta: 1

// BaseGateway.java
package shop.payment;
public abstract class BaseGateway implements PaymentGateway { }        // abstracta: 1

// CardGateway.java
package shop.payment;
public class CardGateway extends BaseGateway {                         // concreta
    public void charge(long cents) {
        Runnable log = new Runnable() { public void run() { } };       // anónima: no cuenta
        log.run();
    }
    static class Retry { }                                             // anidada concreta
}

// Currency.java
package shop.payment;
public enum Currency { EUR, USD }                                      // concreta

// Audited.java
package shop.payment;
public @interface Audited { }                                          // anotación: abstracta (es una interfaz)

Clases: PaymentGateway, BaseGateway, CardGateway, CardGateway.Retry, Currency y Audited, seis. Abstractas: PaymentGateway, BaseGateway y Audited, tres. A=3/6=A = 3 / 6 = 0,5. Un test de CardGateway en el mismo paquete, en la carpeta de tests, no cambiaría el resultado.

Cómo interpretarla

No hay umbral, porque el valor adecuado depende del papel del paquete:

  • Cerca de 0. Normal en paquetes de implementación, de aplicación o de interfaz de usuario, de los que no depende casi nadie. Preocupa en un paquete del que depende mucho código: es la «zona de dolor» que describe la «distancia».
  • Cerca de 1. Normal en paquetes de API o de puertos, que definen contratos para que otros los implementen. Preocupa cuando nadie los usa: abstracciones sin cliente.
  • Valores intermedios. Corrientes en paquetes que mezclan los contratos con sus implementaciones por defecto.

Ojo. La métrica cuenta clases, no su peso. Una interfaz de un método y una clase concreta de dos mil líneas pesan lo mismo. Un paquete puede tener A = 0,5 con casi todo su código en la parte concreta.

Relación con otras métricas

En las herramientas

Stau Metro (Abstractness, a nivel de paquete). Divide las clases abstractas e interfaces del paquete entre el total de sus clases. Las reglas:

  • Cuentan las clases con nombre del paquete, incluidas las anidadas, los enumerados, los record y los tipos de anotación.
  • Son abstractas las interfaces, los tipos de anotación (en Java son interfaces) y las clases marcadas abstract. Un enumerado nunca es abstracto, aunque declare métodos abstractos.
  • No cuentan las clases anónimas, las locales ni las de test. Un paquete que solo contiene tests no tiene valor.
  • Cada paquete se mide por separado: las clases de shop.payment.card no cuentan para shop.payment.
  • Solo se ven las clases Java de los ficheros del ámbito analizado; las de Kotlin no entran, y si el ámbito cubre solo parte de un paquete, el valor es el de esa parte.

A diferencia de la inestabilidad y la distancia, tiene valor aunque el paquete no dependa de otros ni otros de él.

JDepend. Define la abstracción como la proporción de clases abstractas, interfaces incluidas, sobre el total de clases del paquete analizado, con rango de 0 (totalmente concreto) a 1 (totalmente abstracto).

NDepend (.NET). La define como la proporción de tipos abstractos internos (clases abstractas e interfaces) sobre el total de tipos internos, por ensamblado.

Referencias