Inestabilidad

Actualizado el 15 de noviembre de 2026

Sigla I
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 Instability

En pocas palabras

Compara lo que un paquete necesita de otros con lo que otros necesitan de él. Un paquete del que depende medio proyecto y que no depende de nadie vale 0: es estable, porque cambiarlo es caro y nada lo obliga a cambiar. Uno que usa muchos paquetes y al que nadie usa vale 1: es inestable, cualquier cambio a su alrededor le afecta, pero se puede cambiar sin romper a nadie.

Qué mide

Aquí la estabilidad no es la frecuencia con que cambia un paquete, sino lo difícil que es cambiarlo. Un paquete es difícil de cambiar cuando muchos otros dependen de él, y tiene pocos motivos para cambiar cuando él no depende de otros. La inestabilidad mide lo contrario: lo expuesto que está el paquete a los cambios de fuera y lo libre que está para cambiar.

Se construye con dos recuentos:

  • Acoplamientos aferentes (Ca): las clases de otros paquetes que dependen de clases de este. Es la responsabilidad del paquete: cuánto código se rompe si cambia.
  • Acoplamientos eferentes (Ce): las clases de este paquete que dependen de clases de otros. Es su dependencia: cuántas de sus clases pueden verse afectadas por un cambio de fuera.

Cómo se calcula

I=CeCa+CeI = \frac{C_e}{C_a + C_e}

Vale entre 0 y 1. Si Ca+Ce=0C_a + C_e = 0, el paquete está aislado y la inestabilidad no está definida.

Las herramientas no cuentan lo mismo en Ca y Ce. Martin (1994) contaba clases: Ca es el número de clases de fuera de la categoría que dependen de clases de dentro, y Ce, el de clases de dentro que dependen de clases de fuera. Otras herramientas cuentan paquetes, o las clases de fuera de las que se depende (ver «En las herramientas»). La fórmula es la misma; los números, no.

Ejemplo

Una tienda con tres paquetes:

// shop/model/Order.java
package shop.model;
public class Order { }

// shop/model/Item.java
package shop.model;
public class Item { }

// shop/service/PaymentGateway.java
package shop.service;
public interface PaymentGateway { void charge(long cents); }

// shop/service/OrderService.java
package shop.service;
import shop.model.Order;
public class OrderService {
    private PaymentGateway gateway;          // mismo paquete: no cuenta
    public void place(Order order) { }       // usa shop.model.Order
}

// shop/web/OrderController.java
package shop.web;
import shop.model.Order;
import shop.service.OrderService;
public class OrderController {
    private OrderService service;            // usa shop.service
    public void post(Order order) { }        // usa shop.model
}

// shop/web/ItemView.java
package shop.web;
import shop.model.Item;
public class ItemView {
    public void show(Item item) { }          // usa shop.model
}
Paquete Ca (clases de fuera que lo usan) Ce (clases suyas que usan algo de fuera) I
shop.model 3: OrderService, OrderController, ItemView 0 0 / 3 = 0
shop.service 1: OrderController 1: OrderService 1 / 2 = 0,5
shop.web 0 2: OrderController, ItemView 2 / 2 = 1

OrderController usa dos paquetes, pero en el Ce de shop.web cuenta una sola vez: lo que se cuenta son clases del paquete que dependen de fuera, no dependencias.

Cómo interpretarla

No hay un valor bueno. Un sistema sano tiene paquetes de los dos extremos: núcleos estables (modelo, contratos) y bordes inestables (interfaz de usuario, adaptadores, aplicación), que se pueden cambiar a menudo.

Lo que sí da una regla es la dirección de las dependencias. El principio de dependencias estables de Martin pide depender en la dirección de la estabilidad: un paquete debería depender de paquetes más estables que él, con I menor. En el ejemplo, shop.web (1) depende de shop.service (0,5) y de shop.model (0): se cumple. Si shop.model empezara a usar algo de shop.web, un paquete muy estable pasaría a depender de uno muy inestable.

  • I cerca de 0 en un paquete concreto es el caso delicado: todo el mundo depende de él y no se puede extender sin modificarlo. La «distancia a la secuencia principal» lo detecta.
  • I cerca de 1 en un paquete abstracto también lo es: contratos que nadie usa.

Ojo. Que un paquete aparezca como estable depende de qué se analice. Si el análisis cubre solo una parte del proyecto, los paquetes que lo usan desde fuera de esa parte no cuentan y el paquete parece menos estable de lo que es.

Relación con otras métricas

En las herramientas

Stau Metro (Instability, a nivel de paquete). Ce/(Ca+Ce)C_e / (C_a + C_e), con:

  • Ca: las clases distintas de otros paquetes que dependen de alguna clase del paquete.
  • Ce: las clases del paquete que dependen de al menos una clase de otro paquete. Cada clase cuenta una vez, use las clases de fuera que use.
  • Solo cuentan las clases Java de producción del ámbito analizado: ni las de test, ni las de bibliotecas o del JDK, ni las de Kotlin, ni las de partes del proyecto que no se analizan.
  • Las clases anidadas cuentan como clases propias; las anónimas y las locales forman parte de la clase que las contiene. Cada paquete se mide por separado, sin sus subpaquetes.
  • Un paquete sin Ca ni Ce no tiene valor. Cuenta el ámbito, no el proyecto: un paquete acoplado solo con paquetes que quedan fuera del análisis tampoco lo tiene.

Qué cuenta como dependencia (tipos de campos, parámetros y retorno, llamadas, herencia, anotaciones…) se describe en «acoplamientos eferentes».

JDepend. Misma fórmula, pero Ca es el número de paquetes que dependen de clases del paquete y Ce el de paquetes de los que dependen sus clases.

NDepend (.NET, por ensamblado). Ca es el número de tipos de fuera del ensamblado que dependen de tipos de dentro; Ce, el número de tipos de fuera que usan los tipos de dentro, incluidos los de ensamblados de terceros.

Referencias