Complejidad de diseño

Actualizado el 15 de noviembre de 2026

Sigla iv(G)
Aspecto «Complejidad»
Se mide en método
Tipo de valor recuento (entero, mínimo 1)
Dirección más alto es peor
Origen Thomas J. McCabe y Charles W. Butler, 1989
Familia «Métricas de McCabe»
Stau Metro DesignComplexity

En pocas palabras

De todas las decisiones de un método, cuenta solo las que deciden si se llama o no a otro método. Un método que calcula mucho por su cuenta pero llama siempre a los mismos colaboradores vale 1. Uno en el que cada if lleva a una llamada distinta vale más, y necesita más tests para comprobar que se entiende bien con los demás.

Qué mide

Un método tiene dos clases de lógica. La local solo afecta a sus propias variables: comparar, sumar, asignar. La que interviene en el diseño decide qué otras partes del programa entran en juego: con qué método se sigue, qué objeto se crea. La complejidad de diseño mide la segunda.

Importa sobre todo para los tests de integración, los que comprueban que varios módulos funcionan juntos. Si cada módulo ya se ha probado por separado, en la integración no hace falta repetir todas sus decisiones: basta con recorrer las que cambian qué módulos se llaman. iv(G) dice cuántos caminos de ese tipo tiene un método.

Cómo se calcula

McCabe y Butler (1989) la definen sobre el grafo de flujo de control del método, con una reducción de diseño. El informe NIST 500-235 (Watson y McCabe, 1996) la describe con cinco reglas:

  • regla 0 (llamada): los nodos que contienen una llamada a otro módulo no se eliminan nunca;
  • regla 1 (secuencial): se eliminan las secuencias de nodos sin llamadas (no cambia la complejidad);
  • regla 2 (repetitiva): se eliminan los bucles con la condición al principio que no intervienen en llamadas;
  • regla 3 (condicional): se eliminan las decisiones que no tienen llamadas en su cuerpo;
  • regla 4 (bucle): se eliminan los bucles con la condición al final que no intervienen en llamadas.

Las reglas se aplican una y otra vez hasta que ninguna se puede aplicar. La complejidad de diseño es la complejidad ciclomática del grafo reducido:

iv(G)=v(Gdisen˜o),1≤iv(G)≤v(G)iv(G) = v(G_{\text{diseño}}), \qquad 1 \le iv(G) \le v(G)

Sumada sobre los nn módulos de un programa da su complejidad de integración, el número de tests de integración independientes que recorren el diseño del programa:

S1=(∑i=1niv(Gi))−n+1S_1 = \left(\sum_{i=1}^{n} iv(G_i)\right) - n + 1

Las herramientas para Java aproximan la reducción sobre el árbol sintáctico, con reglas que cambian de una a otra (ver «En las herramientas»).

Ejemplo

Con las reglas de Stau Metro, una decisión suma si alguna de sus ramas (no su condición) contiene una llamada:

int process(int[] values, boolean verbose) {       // 1
    int total = 0;
    for (int v : values) {                          // +1: el cuerpo llama a log()
        if (v < 0) {                                // no suma: la rama solo asigna
            v = 0;
        }
        total += v;
        if (verbose) {                              // +1: la rama llama a log()
            log(v);
        }
    }
    return total > 100 ? cap(total) : total;        // +1: una rama del ?: llama a cap()
}

void log(int v) { System.out.println(v); }
int cap(int total) { return 100; }

Total para process: 1 + 1 + 1 + 1 = 4. Su v(G) es 5: el if (v < 0) es lógica local y no entra. El bucle suma porque su cuerpo contiene una llamada, aunque esté dentro de un if; las decisiones anidadas que llevan a llamadas suman todas.

Una llamada en la condición no basta: if (isValid(x)) { count++; } no suma, porque la llamada se hace siempre, vaya el método por donde vaya.

Cómo interpretarla

  • iv(G) cerca de 1: aunque el método tenga mucha lógica, la integración con los demás es sencilla; casi todo se puede probar con tests unitarios.
  • iv(G) cerca de v(G): casi cada decisión cambia los colaboradores que entran en juego. El método hace de coordinador, y cada camino es un escenario de integración distinto.
  • La proporción iv(G) / v(G) dice qué parte de la complejidad del método es de diseño.

Stau Metro no le da umbral de referencia. Los valores de una aproximación sintáctica no se comparan con los de una herramienta que reduzca el grafo.

Qué hacer con un valor alto: separa la decisión de la acción. Un método que primero calcula qué hay que hacer (lógica local, fácil de probar) y después lo despacha con una sola llamada, o con polimorfismo, tiene una iv(G) baja aunque la decisión sea compleja.

Para profundizar

Origen. McCabe y Butler (1989) presentaron la complejidad de diseño como la extensión al diseño de la prueba estructurada: igual que v(G) da un conjunto base de caminos dentro de un módulo, iv(G) da los caminos de un módulo que importan para integrarlo, y S1S_1 los del programa entero. El informe NIST 500-235 añade que, si en la fórmula de S1S_1 se pone v(G) en lugar de iv(G), el resultado es el número de tests necesario para probar cada resultado de cada decisión del programa de forma independiente.

Reducción parcial. El informe NIST explica que una decisión puede eliminarse aunque su cuerpo contenga una llamada, si queda algún camino por ese cuerpo sin llamadas, y que las reglas de diseño pueden eliminar partes de una decisión. Por eso iv(G) no está ligada a la «complejidad esencial», aunque el cálculo se parezca: según el mismo informe, no hay relación matemática entre las dos.

Qué es una llamada. La definición habla de llamadas a otros módulos. En un lenguaje orientado a objetos hay que decidir qué cuenta: una llamada a un método, crear un objeto con new (que ejecuta un constructor), una referencia a método, una llamada a un método de la propia clase o de una biblioteca. Cada herramienta lo decide a su manera, y eso cambia los valores.

Relación con otras métricas

En las herramientas

Stau Metro (DesignComplexity, a nivel de método). Empieza en 1 y recorre las mismas decisiones que su v(G), pero solo suma las que tienen una llamada en alguna de sus ramas; las demás se consideran reducibles:

  • un if suma si su rama then o su rama else contienen una llamada; un bucle, si su cuerpo la contiene; un catch, si su bloque la contiene; un ? :, si una de sus dos expresiones la contiene;
  • una llamada solo en la condición no cuenta;
  • en una cadena de && o de ||, el primer operando es la condición y los siguientes, las ramas: si alguno a partir del segundo contiene una llamada, la cadena suma todos sus operadores (b && b && isB() suma 2); si solo llama el primero, no suma;
  • en un switch con dos puntos, un grupo de etiquetas suma si alguna de sus sentencias contiene una llamada (con la misma regla: si esa sentencia es un if o un bucle, cuentan sus ramas, no su condición); con flechas, una regla suma si su cuerpo la contiene. default no suma nunca;
  • cuentan como llamada: una llamada a un método (de cualquier clase, también de la propia o de una biblioteca, y también super(…) y this(…)), crear un objeto con new (también una clase anónima) y una referencia a método, incluida A::new. No cuentan crear un array con new ni una referencia como int[]::new;
  • una llamada escrita dentro de una lambda o de una clase anónima que está en la rama cuenta como llamada de la rama, aunque no se ejecute al pasar por ella.

Las decisiones de las lambdas y de las clases anónimas o locales declaradas dentro del método se suman al método. No se calcula para métodos abstractos; un método native vale 1. Los métodos de las clases anónimas de un inicializador de campo y de los cuerpos de las constantes de un enumerado tienen valor propio.

MetricsReloaded (complemento para IntelliJ IDEA). Su código fuente usa reglas parecidas para if, bucles, catch y ? :, con tres diferencias: solo considera llamada una expresión de llamada a método (crear un objeto con new o una referencia a método no cuentan); una cadena de && o de || suma si llama cualquiera de sus operandos, también el primero; y en un switch con dos puntos un grupo solo suma si todas sus sentencias contienen una llamada. Según el código, sus valores pueden quedar por encima o por debajo de los de Stau Metro.

Referencias