Métricas MOOD

Actualizado el 15 de noviembre de 2026

MOOD (Metrics for Object-Oriented Design) es un conjunto de seis medidas que describen un sistema orientado a objetos entero con un porcentaje por mecanismo: cuánto oculta, cuánto hereda, cuánto usa el polimorfismo y cuánto se acoplan sus clases. No señalan una clase concreta. Dan una cifra por proyecto, pensada para comparar proyectos entre sí o un proyecto consigo mismo a lo largo del tiempo.

Para quien empieza. Las métricas de clase, como las de «Chidamber y Kemerer», te dicen qué clase mirar. Las de MOOD te dicen cómo es el proyecto en conjunto: por ejemplo, que el 40 % de los campos son visibles desde otras clases. Para encontrar después a las responsables hay que bajar a las métricas de clase.

Quién, cuándo y para qué

Fernando Brito e Abreu y Rogério Carapuça presentaron el conjunto en 1994, en el 4th International Conference on Software Quality (McLean, Virginia), con el título «Object-Oriented Software Engineering: Measuring and Controlling the Development Process». Al año siguiente, Brito e Abreu, Miguel Goulão y Rita Esteves publicaron en la quinta edición del mismo congreso (Austin, Texas) «Toward the Design Quality Evaluation of Object-Oriented Software Systems». Ese segundo artículo aplica las métricas a cinco bibliotecas de clases en C++ (MFC, la biblioteca de GNU, ET++, NMat y MotifApp), revisa dos de las definiciones a raíz de esa validación y propone los primeros umbrales.

La idea común de las seis es la normalización: el numerador cuenta el uso real de un mecanismo y el denominador, el uso máximo que permitiría el mismo número de clases. Todas son proporciones entre 0 y 1 (se suelen dar en porcentaje). Con ello los autores buscaban cifras que no dependieran del tamaño del sistema y que pudieran compararse entre sistemas distintos.

Las seis métricas

Métrica Sigla Mecanismo Qué cuenta Dirección Stau Metro
«Factor de ocultación de métodos» MHF encapsulación parte de los métodos oculta a las demás clases más alto es mejor la calcula (MethodHidingFactorProject)
«Factor de ocultación de atributos» AHF encapsulación parte de los campos oculta a las demás clases más alto es mejor la calcula (AttributeHidingFactorProject)
«Factor de herencia de métodos» MIF herencia métodos heredados entre métodos disponibles informativa la calcula (MethodInheritanceFactorProject)
«Factor de herencia de atributos» AIF herencia campos heredados entre campos disponibles informativa la calcula (AttributeInheritanceFactorProject)
«Factor de polimorfismo» PF polimorfismo sobrescrituras reales entre las posibles informativa la calcula (PolymorphismFactorProject)
«Factor de acoplamiento» CF acoplamiento pares de clases con dependencia entre los pares posibles más alto es peor la calcula (CouplingFactorProject)

La «dirección» es la del catálogo de Stau Metro, que no da umbral de referencia para ninguna de las seis. PF y CF aparecen en algunos textos como POF y COF.

Las seis se reparten entre tres «aspectos»: «encapsulación», «herencia y polimorfismo» y «acoplamiento». Ninguna mide la cohesión ni el tamaño.

Qué cambió en 1995

La revisión de Brito e Abreu, Goulão y Esteves tocó dos definiciones, y las herramientas no siempre siguen la misma:

  • PF. En 1994 el denominador multiplicaba por el número de descendientes todos los métodos definidos en cada clase; desde 1995, solo los métodos nuevos, los que no sobrescriben ninguno heredado.
  • CF. Desde 1995 la herencia queda fuera: dos clases unidas por herencia no cuentan como cliente y proveedor, y el denominador descuenta esos pares. La herencia ya la miden MIF y AIF.

AHF y MHF se definieron sobre la división de C++ entre miembros públicos (visibles) y privados o protegidos (ocultos). Las herramientas para lenguajes con visibilidad de paquete usan una formulación graduada: cada campo o método pesa según la fracción de las demás clases que lo ven. El mismo código da valores distintos con una y otra, y los umbrales de 1995 se calcularon con la binaria.

Cómo se leen juntas

Las seis cifras no son independientes. Las relaciones más útiles:

  • Ocultación y herencia. Solo se heredan los miembros no privados. Un AHF muy alto deja poco que heredar y baja AIF; lo mismo hacen MHF con MIF y, como un método privado no se puede sobrescribir, con PF.
  • Herencia y polimorfismo. Una sobrescritura saca un método de los heredados (baja MIF) y lo suma a las sobrescrituras reales (sube PF). Un MIF alto con un PF bajo describe subclases que reciben mucho y cambian poco; lo contrario, jerarquías en las que se redefine casi todo.
  • Acoplamiento. CF es la única que mira las relaciones entre clases no emparentadas. Un CF alto no dice qué clases son las responsables: para eso están el «acoplamiento entre objetos» (CBO) y el «número de dependencias» (Dcy) de cada clase.

Para ir de la cifra del proyecto a las clases, cada factor tiene equivalentes por clase: los «atributos heredados» (NAIC) y las «operaciones heredadas» (NOIC) y «sobrescritas» (NOOC), entre otras.

Umbrales propuestos

Brito e Abreu, Goulão y Esteves (1995) tomaron como umbrales iniciales el intervalo de confianza al 90 % de la media de su muestra de cinco bibliotecas C++. Cada página de métrica cuenta el detalle; juntos:

Métrica Intervalo de 1995
MHF 10,4 % a 28,7 %
AHF por encima de 70,2 % (solo límite inferior)
MIF 66,2 % a 80,8 %
AIF 52,4 % a 60,0 %
PF 3,5 % a 9,6 %
CF 3,9 % a 17,7 %

Salvo AHF, todas tienen dos límites: los autores no buscaban maximizar ni minimizar el uso de un mecanismo, sino mantenerlo en un intervalo. Son cifras de cinco bibliotecas de clases en otro lenguaje, construidas alrededor de grandes jerarquías y de una API pública. Una aplicación Java no tiene por qué parecerse a ellas, y la documentación de Project Analyzer recoge otros intervalos de otras fuentes (un MHF aceptable entre el 8 % y el 25 %, un CF que no pase del 12 %) sin respaldarlos. La página sobre «de dónde salen los umbrales» trata el problema en general.

MOOD2

Brito e Abreu amplió el conjunto más tarde. La documentación de Project Analyzer lo atribuye a un informe técnico suyo de 2001, «Using OCL to formalize object oriented metrics definitions», y describe cuatro de sus métricas; según esa misma documentación, MOOD2 tiene más, pero no se prestan al análisis automático del código:

  • OHEF (Operation Hiding Effectiveness Factor) y AHEF (Attribute Hiding Effectiveness Factor): de las clases que pueden acceder a una operación o a un atributo, cuántas acceden de verdad. Miden si la visibilidad declarada es mayor de lo necesario, lo que MHF y AHF no ven.
  • IIF (Internal Inheritance Factor): qué parte de las clases que heredan lo hacen de una clase del propio sistema.
  • PPF (Parametric Polymorphism Factor): qué parte de las clases son genéricas.

Esta referencia no tiene páginas para ellas y Stau Metro no las calcula.

Validación y críticas

Independencia del tamaño. El propio artículo de 1995 midió la correlación de cada factor con el número de clases, métodos, atributos y líneas. CF y AIF salieron poco correlacionados, MHF y PF de forma moderada, y AHF y MIF fuertemente; los autores lo atribuyeron más probablemente a lo pequeño de la muestra que a las definiciones, pero dejaron la cuestión abierta. Las cifras están en cada página de métrica.

Calidad. Brito e Abreu y Walcélio Melo (1996) relacionaron los factores con la densidad de defectos y el esfuerzo de corrección en ocho sistemas pequeños construidos con los mismos requisitos. Según el resumen de la documentación de Project Analyzer, valores mayores de MHF, MIF y PF se asociaban con menos defectos y menos retrabajo, y un CF mayor, con más.

Teoría de la medición. Rachel Harrison, Steve Counsell y Reuben Nithi (1998) examinaron los seis factores desde la teoría de la medición, frente a las propiedades que pretenden medir, y los aplicaron a datos de tres dominios de aplicación. Concluyeron que, una vez resueltas algunas discontinuidades de las definiciones, pueden dar una valoración global del sistema útil para quien dirige el proyecto, y que hacían falta más estudios empíricos para generalizar. La «teoría de la medición» explica qué se exige a una medida.

Problemas que aparecen al aplicarlas a Java. Las páginas de cada métrica los detallan; en resumen:

  • Una cifra de sistema esconde las clases. Una sola clase de constantes puede hundir el AHF de un proyecto bien encapsulado, y un AHF aceptable no impide que una clase exponga todo su estado.
  • Qué es «clase» cambia el denominador. Contar o no interfaces, clases anidadas, anónimas o de test mueve todos los factores, porque todos dividen por algo que depende del número de clases.
  • Qué es «heredado» no está cerrado. Constructores, métodos estáticos, métodos por defecto de las interfaces y métodos de la biblioteca estándar: la definición, escrita para C++, no los resuelve, y cada herramienta decide.
  • PF puede pasar de 100 % si se cuentan sobrescrituras de métodos que el análisis no ve (los del JDK, por ejemplo), porque no han aportado sobrescrituras posibles al denominador.
  • CF baja al crecer el sistema. El denominador crece con el cuadrado del número de clases y el numerador, en un diseño corriente, más o menos en proporción a ellas.

La consecuencia práctica es la misma para las seis: compara valores calculados con la misma herramienta, y mejor en el mismo proyecto a lo largo del tiempo que entre proyectos.

En las herramientas

Stau Metro calcula las seis, solo para el proyecto entero y sobre las clases Java del ámbito analizado (también interfaces, enumerados, records, anotaciones, clases anidadas y código de test). Las decisiones que más pesan:

  • AHF y MHF usan la formulación graduada, con la visibilidad efectiva de cada miembro (la suya y la de su clase).
  • CF excluye la herencia del numerador, como la revisión de 1995, pero conserva el denominador de 1994, TC×(TC−1)TC \times (TC - 1); en proyectos con jerarquías da algo menos que la definición de 1995. Una dependencia es cualquier referencia a la clase, no solo el uso de sus métodos o atributos.
  • PF sigue el denominador de 1995 y cuenta como sobrescritura implementar un método de una interfaz del ámbito. Sobrescribir solo métodos de fuera del ámbito cuenta como no sobrescribir nada, así que no pasa de 100 %.
  • MIF y AIF cuentan como heredados los miembros no privados de antepasados con código fuente en el proyecto, aunque estén fuera del ámbito; los de bibliotecas no cuentan.
  • Las clases anónimas y locales solo intervienen en PF; en las otras cinco no son clases de la población.
  • Ninguna tiene umbral de referencia.

Project Analyzer (Aivosto, para Visual Basic) documenta las seis métricas MOOD y las cuatro de MOOD2. Usa la formulación graduada para AHF y MHF, excluye la herencia (Inherits) de CF y solo cuenta la herencia de implementación en MIF, AIF y PF.

MetricsReloaded (plugin de IntelliJ IDEA) incluye las seis y remite a Brito e Abreu para su definición. Según su código fuente, su CF divide entre TC×(TC−1)/2TC \times (TC - 1) / 2 e incluye las dependencias hacia las superclases, y su PF cuenta como sobrescritura cualquier método que tenga un método padre, también si es del JDK.

La página de «herramientas» compara estas y otras herramientas en conjunto.

Referencias

  • Brito e Abreu, F. y Carapuça, R. (1994). «Object-Oriented Software Engineering: Measuring and Controlling the Development Process». 4th International Conference on Software Quality, McLean (Virginia). https://doi.org/10.5281/zenodo.1217609
  • Brito e Abreu, F., Goulão, M. y Esteves, R. (1995). «Toward the Design Quality Evaluation of Object-Oriented Software Systems». 5th International Conference on Software Quality, Austin (Texas). https://doi.org/10.5281/zenodo.1217073
  • Brito e Abreu, F. y Melo, W. (1996). «Evaluating the Impact of Object-Oriented Design on Software Quality». Proceedings of the 3rd International Software Metrics Symposium (METRICS'96), 90-99. https://doi.org/10.1109/METRIC.1996.492446
  • Brito e Abreu, F. (2001). «Using OCL to formalize object oriented metrics definitions». Informe técnico ES007/2001 (citado por la documentación de Project Analyzer; no consultado directamente).
  • Harrison, R., Counsell, S. J. y Nithi, R. V. (1998). «An Evaluation of the MOOD Set of Object-Oriented Software Metrics». IEEE Transactions on Software Engineering, 24(6), 491-496. https://doi.org/10.1109/32.689404
  • Aivosto, Project Analyzer, «MOOD and MOOD2 metrics»: https://www.aivosto.com/project/help/pm-oo-mood.html
  • MetricsReloaded, código fuente: https://github.com/BasLeijdekkers/MetricsReloaded