Número de operaciones añadidas

Actualizado el 15 de noviembre de 2026

Sigla NOAC
Aspecto «Herencia y polimorfismo»
Se mide en clase
Tipo de valor recuento (entero, mínimo 0)
Dirección informativa: ni alto ni bajo es mejor
Origen sin definición original comprobada; afín a las métricas de clase de Lorenz y Kidd (1994); ver «Para profundizar»
Familia «Métricas de Lorenz y Kidd»
Stau Metro NumOperationsAdded

En pocas palabras

Cuenta los métodos que una clase aporta de verdad nuevos: los que no se limitan a reescribir algo que ya había implementado más arriba. En programación orientada a objetos, «operación» y «método» son lo mismo.

Qué mide

Cuánto comportamiento nuevo introduce una clase respecto a su jerarquía. Una subclase típica hace dos cosas con los métodos: redefine los heredados para adaptarlos y añade otros. NOAC mide la segunda. Una clase con NOAC alto amplía el contrato de su antepasado; con NOAC bajo y mucha redefinición, lo especializa sin ampliarlo.

Cómo se calcula

Se parte de los métodos declarados en el cuerpo de la clase y se descartan los que no son «añadidos»:

  • No cuentan los constructores ni los métodos abstractos.
  • Cuenta siempre un método private o static, porque ninguno de los dos puede sobrescribir nada.
  • Cualquier otro método cuenta solo si no sobrescribe un método concreto (con cuerpo) de un antepasado.

Un método que implementa un método abstracto, o uno de una interfaz que no es default, sigue contando como añadido: la clase aporta la primera implementación. Un método que sobrescribe un método default de una interfaz, o uno de java.lang.Object como toString, no cuenta.

NOAC(C)=∣{m declarado en C:m no es constructor ni abstracto∧(m es privado o estaˊtico∨m no sobrescribe un meˊtodo concreto)}∣NOAC(C) = |\{m \text{ declarado en } C : m \text{ no es constructor ni abstracto} \land (m \text{ es privado o estático} \lor m \text{ no sobrescribe un método concreto})\}|

Ejemplo

abstract class Animal {
    public abstract String sound();
    public int age() { return 1; }
    public String describe() { return "animal"; }
}

class Dog extends Animal {
    public String sound() { return "woof"; }                // +1 implementa uno abstracto
    @Override public int age() { return super.age() + 1; }  //  0 sobrescribe uno concreto
    public void fetch() { }                                 // +1 nuevo
    private void hide() { }                                 // +1 privado
    static Dog of() { return new Dog(); }                   // +1 estático
    @Override public String toString() { return "Dog"; }    //  0 sobrescribe el de Object
}

NOAC(Dog) = 4 (sound, fetch, hide, of). NOAC(Animal) = 2 (age y describe; sound es abstracto).

Cómo interpretarla

No hay umbrales. Léela junto a «NOOC»: NOAC + NOOC es el total de métodos no abstractos que declara la clase en su código, sin contar constructores, y el reparto dice si la clase amplía su jerarquía o se limita a redefinirla.

Un NOAC muy alto en una subclase puede indicar que acumula responsabilidades. Un NOAC de 0 en una clase con métodos indica que todo lo que declara con cuerpo redefine comportamiento ya implementado más arriba.

Para profundizar

Las fuentes secundarias consultadas atribuyen a Lorenz y Kidd (1994) el número de operaciones que una subclase sobrescribe, pero ninguna les atribuye el de las que añade, que es su complemento. La de las sobrescritas se combina con la profundidad en el «índice de especialización». En esta referencia solo se ha podido comprobar la fórmula de ese índice (métodos de instancia redefinidos por el número de superclases, entre todos los métodos de instancia), en la documentación de una herramienta que cita el libro; ni la redacción original de las operaciones añadidas ni las siglas que usan los autores se han podido consultar. Las decisiones de Stau Metro que pueden diferir de ella son: contar siempre los métodos private y static, y contar como añadido el que implementa uno abstracto.

Relación con otras métricas

En las herramientas

Stau Metro (NumOperationsAdded, a nivel de clase). Se calcula sobre los métodos escritos en el código: los métodos que el lenguaje sintetiza en enumerados y record no cuentan. Se calcula para clases, clases abstractas, enumerados y record; no para interfaces (aunque tengan métodos default) ni interfaces de anotación. Las clases anónimas y las locales no tienen valor propio y sus métodos no se suman a los de la clase que las contiene; las clases anidadas con nombre sí. En un enumerado, los cuerpos de las constantes se tratan como clases anónimas.

La comprobación de «sobrescribe un método concreto» mira, en cada rama de la jerarquía (superclases, Object, interfaces, también las de bibliotecas), el método más cercano que se sobrescribe, y no sigue más arriba. Un método de interfaz es concreto solo si es default. Por eso, si una clase intermedia vuelve a declarar abstracto un método concreto, sobrescribirlo cuenta como añadido; y en un record, un toString, equals o hashCode escrito a mano también cuenta como añadido, porque en java.lang.Record son abstractos. El código de test se trata igual que el de producción. Solo cubre Java.

Referencias