Respuesta para la clase
| Sigla | RFC |
| Aspecto | «Acoplamiento» |
| Se mide en | clase |
| Tipo de valor | entero, mínimo 0: tamaño de un conjunto de métodos distintos |
| Dirección | más alto es peor |
| Umbrales de referencia | aviso por encima de 50, error por encima de 100 (Stau Metro) |
| Origen | Shyam R. Chidamber y Chris F. Kemerer, 1994 |
| Familia | «Métricas de Chidamber y Kemerer» |
| Stau Metro | ResponseForClass |
En pocas palabras
Suma los métodos que tiene una clase y los métodos distintos a los que esos métodos llaman. Es una estimación de cuánto código puede ponerse en marcha cuando alguien usa la clase. Cuanto mayor es, más cosas pueden pasar al llamar a la clase, y más difícil es probarla y entender sus efectos.
Qué mide
Mide el conjunto de respuesta de una clase: los métodos que pueden ejecutarse, de forma directa, cuando un objeto de la clase recibe un mensaje (una llamada a uno de sus métodos). Son los métodos de la propia clase más los que estos invocan, tanto de la clase como de otras.
Combina dos cosas en un número:
- Tamaño de la interfaz de la clase: cuántos métodos ofrece y tiene.
- Alcance de sus llamadas: con cuántos métodos de fuera colabora.
Importa sobre todo para los tests y la depuración: cuantos más métodos intervienen en la respuesta, más escenarios hay que considerar y más sitios donde buscar un fallo.
Para quien empieza. Llamar dos veces al mismo método cuenta una vez: lo que se cuenta son métodos distintos, no llamadas. Y dos sobrecargas (
print(int)yprint(String)) son dos métodos distintos.
Cómo se calcula
Chidamber y Kemerer definen el conjunto de respuesta como la unión de los métodos de la clase, , con los conjuntos de métodos llamados por cada método de la clase:
Solo se mira un nivel de llamadas: los métodos que llaman los métodos de la clase, no los que llaman estos a su vez. Como y los se unen como conjuntos, una llamada de la clase a uno de sus propios métodos no añade nada: ese método ya está en .
Lo que las herramientas resuelven de forma distinta:
- si los constructores cuentan como métodos de la clase y si las llamadas a constructores de otras clases (
new) entran en ; - si cuentan los métodos de bibliotecas (
List.add,Math.max); - qué pasa con las llamadas hechas desde clases anónimas, lambdas o clases anidadas;
- cómo se distinguen las sobrecargas cuando el análisis no resuelve los tipos.
Ejemplo
import java.util.List;
class Line {
private final long amount;
Line(long amount) { this.amount = amount; }
long amount() { return amount; }
}
class Invoice {
private final List<Line> lines;
Invoice(List<Line> lines) { // M: Invoice(List)
this.lines = lines;
}
void add(Line line) { // M: add
lines.add(line); // R: List.add
}
long total() { // M: total
long sum = 0;
for (Line line : lines) {
sum += line.amount(); // R: Line.amount
}
return applyDiscount(sum); // ya está en M
}
private long applyDiscount(long sum) { // M: applyDiscount
return Math.max(0, sum - discount()); // R: Math.max(long, long); discount ya está en M
}
long discount() { // M: discount
return 0;
}
}
Métodos de la clase, : el constructor, add, total, applyDiscount y discount (5). Métodos llamados que no
están ya en : List.add, Line.amount y Math.max (3). Total: 5 + 3 = 8.
Las llamadas a applyDiscount y a discount no suman: son métodos de la clase y ya están contados.
Cómo interpretarla
Un RFC alto puede venir de dos sitios, y conviene distinguirlos:
- Muchos métodos propios. Es una clase grande; compárala con el «tamaño de la clase en operaciones».
- Muchas llamadas a métodos distintos de fuera. La clase colabora con mucho código. Si además el «acoplamiento entre objetos» es alto, suele ser una clase con demasiadas responsabilidades.
Stau Metro usa como referencia aviso por encima de 50 y error por encima de 100. Ninguno de los dos procede de una fuente publicada primaria.
Qué hacer con un valor alto:
- Divide la clase. Agrupa los métodos por los colaboradores que usan; cada grupo es una clase candidata.
- Encapsula a los colaboradores. Si la clase llama a diez métodos de una misma biblioteca, una clase intermedia con dos o tres métodos de intención clara reduce el conjunto de respuesta.
- Evita las cadenas de llamadas largas (
a.getB().getC().doIt()): cada eslabón es un método más en la respuesta y una dependencia más de la estructura de otras clases.
Cuándo un valor alto es aceptable. Una fachada o un adaptador que traduce una API amplia tiene un RFC alto por
definición. También lo tienen las clases que usan mucho una biblioteca rica, como un constructor de consultas o de
documentos: cada método de la biblioteca suma uno.
Ojo. Los métodos de bibliotecas cuentan igual que los propios. Una clase que usa veinte métodos de
Stringy de las colecciones ya tiene unRFCde veinte más sus métodos, sin estar acoplada a ninguna clase del proyecto.
Para profundizar
Un nivel o todos. La versión de 1994 solo cuenta las llamadas directas. Briand, Daly y Wüst (1999) leen la de
1991, que hablaba de «todos los métodos que pueden invocarse en respuesta a un mensaje», como el cierre transitivo:
la llaman RFC′ (o RFC∞) y definen además RFCα, que sigue las llamadas hasta niveles. La versión
transitiva mide mejor el alcance real de un mensaje, pero cuesta mucho más de calcular y depende de cómo se resuelvan
las llamadas polimórficas.
Llamadas polimórficas. Un análisis estático resuelve cada llamada al método declarado en el tipo estático del
receptor. Una llamada a shape.area() sobre una variable Shape cuenta Shape.area, no las implementaciones que se
ejecutarán de verdad. El RFC estático es, por tanto, una aproximación del conjunto de respuesta real.
Mezcla dos dimensiones. Al sumar métodos propios y métodos llamados, el RFC se correlaciona con el tamaño de la
clase. Si se quiere separar el acoplamiento del tamaño, mira por separado los métodos propios y el resto. Por la
misma razón, el RFC nunca vale 0 en una clase con métodos, aunque no llame a nada: Briand, Daly y Wüst lo señalan
como una de las propiedades de las medidas de acoplamiento que no cumple.
Evidencia empírica. En el estudio de Basili, Briand y Melo (1996) sobre ocho sistemas en C++, el RFC resultó
un predictor muy significativo de las clases con fallos: cuanto mayor el RFC, mayor la probabilidad de encontrar
un fallo en la clase. El Emam y otros (2001) encontraron después que, en sus datos, las métricas de Chidamber y
Kemerer dejaban de asociarse con los fallos al controlar el tamaño de la clase, que es justo lo que el RFC mezcla
con el acoplamiento.
Relación con otras métricas
- «Acoplamiento entre objetos» (
CBO): cuenta clases distintas; elRFCcuenta métodos. Se leen juntas. - «Acoplamiento por paso de mensajes» (
MPC): cuenta todas las llamadas, repetidas incluidas; elRFCsolo los métodos distintos. - «Número de llamadas a métodos» (
CALL): el recuento de llamadas por método, que sumado da una idea del volumen detrás delRFC. - «Tamaño de la clase (operaciones)» (
CSO): la parte delRFC, contada a su manera. - «Complejidad ponderada de los métodos» (
WMC): otra métrica de CK que crece con el tamaño de la clase. - «Fan-in y fan-out»: el
RFCes una forma de fan-out medida en métodos.
En las herramientas
Stau Metro (ResponseForClass, a nivel de clase). Une los métodos declarados en la clase con los métodos a los
que resuelven las llamadas de su código, y cuenta los distintos.
- Se mide en las clases con nombre, también abstractas, enumerados, records y clases anidadas; no en interfaces, anotaciones, clases anónimas ni clases locales.
- son los métodos escritos en la clase, constructores y métodos abstractos incluidos. Los miembros implícitos no
cuentan: el constructor por defecto,
values()yvalueOf()de un enumerado, los accesores implícitos de un record. - Entran en las llamadas a métodos y las creaciones de objetos (
new) que resuelven a un constructor declarado en la clase de destino, sea del proyecto o de una biblioteca; tambiénsuper(…)ythis(…). Unnewde una clase del proyecto que no declara constructores no añade nada; el de un record sí, porque resuelve a su constructor canónico implícito. Las referencias a método (Foo::bar) no son llamadas y no cuentan, y tampoco los argumentos de una constante de enumerado (RED(255)). - Cuentan los métodos de cualquier origen: de la propia clase, de otras clases del proyecto, del JDK y de bibliotecas. Una llamada que no se puede resolver no cuenta.
- Cuentan las llamadas del cuerpo de los métodos, incluidas las de las lambdas, y las de los inicializadores de campos y de los bloques de inicialización. No cuentan las hechas desde una clase anidada, anónima o local declarada dentro de la clase.
CK (Aniche). Su RFC cuenta las invocaciones de métodos únicas de una clase. Según su documentación, como las
llamadas se resuelven por análisis estático, falla cuando un método tiene sobrecargas con el mismo número de
parámetros pero de tipos distintos.
Referencias
- Chidamber, S. R. y Kemerer, C. F. (1994). «A Metrics Suite for Object Oriented Design». IEEE Transactions on Software Engineering, 20(6), 476-493. https://doi.org/10.1109/32.295895
- Chidamber, S. R. y Kemerer, C. F. (1991). «Towards a Metrics Suite for Object Oriented Design». OOPSLA '91, 197-211.
- Briand, L. C., Daly, J. W. y Wüst, J. K. (1999). «A Unified Framework for Coupling Measurement in Object-Oriented Systems». IEEE Transactions on Software Engineering, 25(1), 91-121. https://doi.org/10.1109/32.748920
- Basili, V. R., Briand, L. C. y Melo, W. L. (1996). «A Validation of Object-Oriented Design Metrics as Quality Indicators». IEEE Transactions on Software Engineering, 22(10), 751-761.
- El Emam, K., Benlarbi, S., Goel, N. y Rai, S. N. (2001). «The Confounding Effect of Class Size on the Validity of Object-Oriented Metrics». IEEE Transactions on Software Engineering, 27(7), 630-650.
- CK, métricas de código Java de Maurício Aniche: https://github.com/mauricioaniche/ck