Índice de especialización

Actualizado el 15 de noviembre de 2026

Sigla SIX (Specialization Index)
Aspecto «Herencia y polimorfismo»
Se mide en clase
Tipo de valor proporción (decimal, mínimo 0, sin máximo fijo)
Dirección más alto es peor
Umbrales de referencia anomalía a partir del 15 % (Lorenz y Kidd, 1994, según Balmas y colegas, 2009)
Origen Mark Lorenz y Jeff Kidd, 1994
Familia «Métricas de Lorenz y Kidd»
Stau Metro no la calcula

En pocas palabras

Una subclase puede añadir cosas a lo que hereda o cambiar lo que hereda. Este índice mide cuánto cambia: cuenta los métodos heredados que la clase sobrescribe, lo multiplica por lo profunda que está en la jerarquía y lo divide entre su número de métodos. Un valor alto indica una subclase que, más que extender a sus padres, los corrige.

Qué mide

Mide el grado de especialización por sobrescritura de una subclase. La idea de fondo es que una buena subclase suele ser una extensión de las capacidades de sus superclases: añade comportamiento y redefine poco. Una subclase que sobrescribe muchos métodos de superclases que no son abstractas probablemente no encaja bien con la abstracción de sus padres.

Como la profundidad multiplica, la misma sobrescritura pesa más cuanto más abajo está la clase: hay más antepasados cuyo comportamiento se está cambiando y más niveles que revisar para entender qué hace de verdad un método.

Para quien empieza. Sobrescribir (en inglés, override) es declarar en una subclase un método con la misma firma que uno heredado, para que se ejecute el de la subclase. En Java se marca con @Override.

Cómo se calcula

Lorenz y Kidd lo definen como el número de métodos sobrescritos por la clase, multiplicado por su nivel de anidamiento en la jerarquía de clases y dividido entre su número total de métodos:

SIX=NORM×DITNOM\mathit{SIX} = \frac{\mathit{NORM} \times \mathit{DIT}}{\mathit{NOM}}

donde NORM\mathit{NORM} es el número de métodos sobrescritos, DIT\mathit{DIT} la profundidad de la clase en la jerarquía y NOM\mathit{NOM} el número de métodos de la clase. «Número total de métodos» admite dos lecturas: Eclipse Metrics toma los métodos definidos en la clase, y la recopilación de Balmas y colegas (2009) escribe el denominador como los métodos definidos más los heredados (NOM+NIM\mathit{NOM} + \mathit{NIM}).

Según la recopilación de Balmas y colegas (2009), Lorenz y Kidd precisan que no se cuentan como sobrescritos los métodos que invocan al método de la superclase (con super) ni los que sobrescriben una plantilla. Es decir, el índice quiere contar los métodos que reemplazan el comportamiento heredado, no los que lo amplían o rellenan un hueco previsto por la superclase.

Las herramientas y los textos posteriores no coinciden en los detalles:

Pieza Opciones que se encuentran
Numerador todos los métodos sobrescritos, o sin los que llaman a super; con o sin los que implementan un método abstracto
Profundidad contando Object (una clase sin extends vale 1), o solo las superclases del proyecto
Denominador métodos declarados en la clase (Eclipse Metrics), o declarados más heredados (Balmas y colegas)

Ejemplo

abstract class Shape {
    abstract double area();
    String name() { return "shape"; }
    String describe() { return name() + " " + area(); }
}

class Rectangle extends Shape {                               // DIT 2 (Shape, Object)
    final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }  // constructor: no es un método
    @Override double area() { return w * h; }                 // implementa un abstracto
    @Override String name() { return "rectangle"; }           // sobrescribe un método concreto
    double perimeter() { return 2 * (w + h); }                // añadido
}

class Square extends Rectangle {                              // DIT 3 (Rectangle, Shape, Object)
    Square(double side) { super(side, side); }
    @Override String name() { return "square"; }              // sobrescribe
    @Override String describe() { return "[] " + super.describe(); } // sobrescribe, pero llama a super
    @Override double perimeter() { return 4 * w; }            // sobrescribe
}

Con la profundidad contada desde Object y los métodos declarados como denominador:

Square. Declara 3 métodos y los 3 sobrescriben un método concreto.

  • Contando todos: SIX=3×3/3\mathit{SIX} = 3 \times 3 / 3 = 3,0.
  • Sin describe, que llama a super (la regla de Lorenz y Kidd): SIX=2×3/3\mathit{SIX} = 2 \times 3 / 3 = 2,0.

Rectangle. Declara 3 métodos; name sobrescribe uno concreto y area implementa uno abstracto.

  • Contando solo la sobrescritura de métodos concretos: SIX=1×2/3\mathit{SIX} = 1 \times 2 / 3 ≈ 0,67.
  • Contando también la implementación del abstracto: SIX=2×2/3\mathit{SIX} = 2 \times 2 / 3 ≈ 1,33.

Las dos clases superan con mucho el 15 %. En parte es real (Square reescribe casi todo lo que hereda de Rectangle, el caso clásico de herencia dudosa) y en parte es un efecto del tamaño: con solo tres métodos, cada sobrescritura pesa un tercio del denominador.

Cómo interpretarla

Según Balmas y colegas (2009), Lorenz y Kidd sitúan el umbral de anomalía en el 15 % e ilustran ese valor con una clase de profundidad 1 que sobrescribe 3 de sus 20 métodos: 3×1/20=0,153 \times 1 / 20 = 0{,}15. Como la profundidad multiplica, la misma clase con 3 sobrescrituras a profundidad 3 necesitaría 60 métodos para quedarse en ese umbral.

Un valor alto puede indicar:

  • una subclase que no es un subtipo natural de su padre y lo «corrige» método a método;
  • una jerarquía profunda en la que cada nivel redefine lo que acaba de heredar;
  • una superclase concreta cuyo comportamiento casi nadie usa tal cual, y que quizá debería ser abstracta.

Qué hacer. Mira qué métodos se sobrescriben y por qué. Si la superclase define comportamiento que casi todas las subclases reemplazan, conviene convertirlo en abstracto o en un punto de extensión explícito (el patrón Template Method). Si la subclase solo comparte con el padre unos pocos métodos, la composición suele encajar mejor que la herencia.

Cuándo un valor alto es aceptable.

  • Métodos de Object. Sobrescribir toString, equals y hashCode es normal y no indica mala herencia; algunas herramientas permiten excluirlos.
  • Puntos de extensión previstos. Las subclases de un framework sobrescriben los métodos que el framework les pide; la regla de Lorenz y Kidd que excluye las plantillas va en esa dirección.
  • Clases pequeñas. Con pocos métodos, una sola sobrescritura dispara el índice.

Ojo. El índice mezcla dos cosas (cuánto se sobrescribe y a qué profundidad) en un solo número. Un mismo valor puede salir de una clase poco profunda que lo redefine todo o de una muy profunda que redefine un método.

Para profundizar

Críticas. La recopilación de Balmas y colegas (2009) para el proyecto Squale lo describe como una métrica bien definida, sin ambigüedad y fácil de calcular, pero sin validación teórica ni empírica, y añade que, al depender de DIT, hereda sus limitaciones. Recoge además la crítica de Mayer (1999): la medida parece razonable, pero en la práctica es tan gruesa e inconsistente que resulta inútil, y bastaría con multiplicar los métodos sobrescritos por la profundidad, porque dividir entre el número de métodos «no añade nada» y reduce mucho su precisión. Los autores del informe proponen leerla no como un índice de calidad, sino como una señal para mirar una clase con más atención, y tras citar a Mayer desaconsejan usarla.

Qué es un método sobrescrito. Es la fuente principal de diferencias entre herramientas. Implementar un método abstracto o un método de una interfaz ¿es sobrescribir? En sentido estricto del lenguaje sí, pero no redefine comportamiento heredado. Sobrescribir llamando a super ¿cuenta? Lorenz y Kidd dicen que no. Eclipse Metrics deja estas dos decisiones como opciones.

Qué es la profundidad. Si se cuenta desde Object, una clase que no extiende nada vale 1 y su SIX puede ser mayor que 0 por sobrescribir toString. Si se cuentan solo las superclases propias del proyecto, la misma clase vale 0. Las superclases de bibliotecas y frameworks suben la profundidad sin que la jerarquía propia sea profunda.

Relación con otras métricas

En las herramientas

Stau Metro no calcula SIX, pero calcula sus piezas por clase: «NumOperationsOverridden» (NOOC, métodos con cuerpo que sobrescriben un método concreto de una superclase o interfaz), «NumOperationsAdded» (NOAC, métodos declarados que no sobrescriben uno concreto, sin constructores ni métodos abstractos; implementar un abstracto cuenta como añadido) y «DepthOfInheritance» (DIT, contada hasta Object inclusive; no se mide en enumerados ni en record). Con ellas se puede calcular a mano la variante de métodos concretos y denominador de métodos declarados:

SIX≈NOOC×DITNOOC+NOAC\mathit{SIX} \approx \frac{\mathit{NOOC} \times \mathit{DIT}}{\mathit{NOOC} + \mathit{NOAC}}

En el ejemplo de arriba, Square tiene NOOC = 3, NOAC = 0 y DIT = 3, lo que da 3,0; Rectangle tiene NOOC = 1, NOAC = 2 y DIT = 2, lo que da 0,67. Esta aproximación no aplica la regla de Lorenz y Kidd sobre los métodos que llaman a super, porque NOOC los cuenta.

Eclipse Metrics (complemento de Eclipse). Define el índice como NORM * DIT / NOM, a nivel de clase, con DIT como la distancia a Object y NOM como el número de métodos definidos. En sus preferencias se puede elegir si NORM cuenta los métodos abstractos y los que llaman a la implementación heredada con super, y excluir toString, equals y hashCode.

ENVY/QA (VA Smalltalk). Lo calcula como los métodos de instancia redefinidos por el número de superclases, entre el total de métodos de instancia. Su documentación explica que una buena subclase suele extender las capacidades de sus superclases, y que un valor alto puede indicar una subclase pobre y problemas de diseño.

Referencias