Respuesta para la clase

Actualizado el 15 de noviembre de 2026

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) y print(String)) son dos métodos distintos.

Cómo se calcula

Chidamber y Kemerer definen el conjunto de respuesta RSRS como la unión de los métodos de la clase, MM, con los conjuntos RiR_i de métodos llamados por cada método ii de la clase:

RS=M∪⋃i∈MRiRFC=∣RS∣RS = M \cup \bigcup_{i \in M} R_i \qquad RFC = |RS|

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 MM y los RiR_i 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 MM.

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 RiR_i;
  • 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, MM: el constructor, add, total, applyDiscount y discount (5). Métodos llamados que no están ya en MM: 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:

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 String y de las colecciones ya tiene un RFC de 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 α\alpha 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

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.
  • MM 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() y valueOf() de un enumerado, los accesores implícitos de un record.
  • Entran en RiR_i 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én super(…) y this(…). Un new de 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