Factor de ocultación de métodos
| Sigla | MHF |
| Aspecto | «Encapsulación» |
| Se mide en | proyecto |
| Tipo de valor | proporción, que se muestra como porcentaje (0 % a 100 %) |
| Dirección | más alto es mejor |
| Origen | Fernando Brito e Abreu y Rogério Carapuça, 1994 |
| Familia | «Métricas MOOD» |
| Stau Metro | MethodHidingFactorProject |
En pocas palabras
Dice qué parte de los métodos del proyecto está escondida del resto de clases. Si todos los métodos fueran
private, valdría 100 %; si todos fueran public en clases públicas, 0 %. Un proyecto sano queda entre medias:
cada clase ofrece unos pocos métodos públicos y resuelve el trabajo con métodos auxiliares ocultos.
Qué mide
Mide cuánto de la funcionalidad de las clases queda tras su interfaz pública. Los métodos visibles son el contrato que otras clases pueden usar; los ocultos son detalles de implementación que la clase puede cambiar libremente.
A diferencia del «factor de ocultación de atributos», aquí el 100 % no es la meta. Una
clase sin métodos visibles no sirve a nadie. Brito e Abreu, Goulão y Esteves (1995) lo explican así: el número de
métodos visibles mide la funcionalidad de la clase, y esa funcionalidad debería implementarse descomponiéndola en
métodos ocultos, de modo que la interfaz sea «la punta del iceberg». Un MHF muy bajo indicaría una implementación
poco abstraída; uno muy alto, muy poca funcionalidad.
Cómo se calcula
La definición original es la del «factor de ocultación de atributos» aplicada a los métodos definidos (no heredados) en cada clase:
con los métodos visibles y los ocultos de la clase . En la correspondencia con C++ de 1995 son
métodos los constructores, los destructores, las funciones miembro (también las virtuales) y los operadores; los
visibles son los de la sección public y los ocultos, los de private y protected. Los métodos sobrecargados con
distinta lista de parámetros cuentan como métodos distintos.
La formulación graduada, que usan las herramientas para lenguajes con visibilidad de paquete, pesa cada método por la fracción de las otras clases que lo ven:
Ejemplo
Tres clases en dos paquetes, cada una en su fichero (: cada método lo pueden ver como mucho 2 clases):
// paquete p
public class Account {
public Account() { } // V = 2/2: constructor público
public void deposit(int amount) { } // V = 2/2
protected void audit() { } // V = 2/2: Audit (paquete) y SavingsAccount (subclase)
void touch() { } // V = 1/2: solo Audit
private void check() { } // V = 0/2
}
// paquete p
class Audit { } // sin métodos declarados
// paquete q
public class SavingsAccount extends p.Account {
public void addInterest() { } // V = 2/2
}
Ocultación de cada método, : 0 + 0 + 0 + 0,5 + 1 + 0 = 1,5. Hay 6 métodos: .
El constructor por defecto que el compilador añade a Audit y a SavingsAccount no está escrito en el código y no
cuenta.
Cómo interpretarla
Un MHF alto significa que la mayoría de los métodos están ocultos; uno bajo, que las clases exponen casi todo lo
que hacen. Brito e Abreu, Goulão y Esteves (1995) la tratan como una métrica con dos límites y proponen como
umbrales iniciales el intervalo de confianza al 90 % de la media de su muestra de cinco bibliotecas C++: entre
10,4 % y 28,7 %. Esas cifras salen de bibliotecas de clases (cuya razón de ser es ofrecer una API pública)
y de la definición binaria, en la que protected cuenta como oculto.
Stau Metro no tiene umbral de referencia para esta métrica.
Qué hacer con un valor bajo: revisa las clases con una API pública amplia. Métodos públicos que solo se llaman
desde la propia clase pueden pasar a private; métodos de paquete que nadie fuera de la clase usa, también. Una API
pública grande puede ser también síntoma de una clase con demasiadas responsabilidades.
Cuándo un valor bajo es aceptable. Las interfaces, cuyos métodos son públicos por definición, los getters y setters, los métodos de test (públicos o de paquete) y las bibliotecas cuyo propósito es una API amplia bajan el valor sin que el diseño sea peor.
Para profundizar
Evidencia. Brito e Abreu y Melo (1996) relacionaron las métricas MOOD con la densidad de defectos y el esfuerzo
de corrección en ocho sistemas pequeños de gestión construidos con los mismos requisitos; según el resumen que hace
la documentación de Project Analyzer, un MHF mayor se asociaba con menos defectos y menos retrabajo.
Tamaño. En la muestra de 1995, la correlación de MHF con el número de clases, métodos, atributos y líneas fue
moderada o baja (entre −0,19 y −0,59).
Lo que no ve. MHF mira la visibilidad declarada, no el uso real. Un método público al que nadie llama fuera de
su clase cuenta como visible; para medir si la visibilidad es mayor de lo necesario, la revisión posterior MOOD2
propuso factores de efectividad de la ocultación, que Project Analyzer documenta como OHEF y AHEF.
Relación con otras métricas
- «Factor de ocultación de atributos» (
AHF): la misma fórmula sobre los campos; se leen juntas. - «Factor de herencia de métodos» (
MIF): solo se heredan los métodos no privados, así que ocultar métodos reduce lo que se puede heredar. - «Factor de polimorfismo» (
PF): un método privado no se puede sobrescribir. - «Tamaño de la clase (operaciones)» (
CSO) y «número de métodos» (METH): la base del denominador. - «Ratio de encapsulación» (
E_RAT): la encapsulación de clases dentro de un paquete medida por el uso real.
En las herramientas
Stau Metro (MethodHidingFactorProject, a nivel de proyecto). Usa la formulación graduada, con las mismas reglas
de visibilidad que AHF:
| Visibilidad efectiva | Otras clases que lo ven |
|---|---|
método private, o clase private |
ninguna |
método protected, o clase protected |
las demás clases de su paquete más las subclases de otros paquetes (cada clase una vez) |
método public (o de interfaz) en una clase public |
todas las demás: |
el resto (de paquete, o public en una clase de paquete) |
las demás clases de su paquete |
- Cuentan todos los métodos escritos en el código: constructores, métodos abstractos, estáticos, por defecto de
interfaces y los de las anotaciones. No cuentan los que el compilador genera (el constructor por defecto, los
values()yvalueOf()de un enumerado, los accesores de un record). - son todas las clases Java del ámbito, también interfaces, enumerados, records, anotaciones, anidadas y de test. Las clases anónimas y locales no cuentan como clases, ni sus métodos, ni como subclases.
- Las subclases son las directas e indirectas que están en el ámbito analizado; las interfaces no cuentan como subclases.
- Sin métodos, o con una sola clase, no hay valor.
Project Analyzer (Aivosto, para Visual Basic). Documenta MHF = 1 − MethodsVisible, con la visibilidad de cada
método medida como el número de otras clases que lo ven dividido entre ; si todos los métodos son privados,
MHF vale 100 %, y si todos son públicos, 0 %.
MetricsReloaded (plugin de IntelliJ IDEA). Calcula MHF a nivel de proyecto y remite a Brito e Abreu para la
definición.
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
- 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 y descripciones: https://github.com/BasLeijdekkers/MetricsReloaded