Número de clases

Actualizado el 15 de noviembre de 2026

Sigla C (C(rec) en la variante recursiva del paquete)
Aspecto «Tamaño»
Se mide en paquete, módulo, proyecto
Tipo de valor recuento (entero, mínimo 0)
Dirección informativa: ni alto ni bajo es mejor
Stau Metro NumClassesPackage, NumClassesRecursivePackage, NumClassesModule, NumClassesProject

En pocas palabras

Cuenta cuántos tipos declara un paquete, un módulo o un proyecto. Es la medida de tamaño más basta que existe en términos de diseño: no dice cuánto código hay, sino entre cuántas piezas está repartido.

Qué mide

El número de unidades de diseño que hay que conocer y mantener. Dos proyectos con las mismas líneas de código pueden tener cien clases o mil: el segundo tiene más piezas pequeñas, y probablemente más relaciones entre ellas.

El nombre engaña un poco. Aquí «clase» significa cualquier tipo declarado: también las interfaces, los enumerados, los tipos de anotación y los records, y además las clases anónimas y las locales.

Cómo se calcula

No hay una definición única en la literatura: es un recuento de declaraciones, y lo único que varía es qué tipos se admiten. La más corriente en las herramientas es contar todos los tipos, nombrados o no, incluidos los anidados.

Ejemplo

package p;

public class Shop {                                              // 1
    interface Pricing {}                                         // 2
    enum Tier { GOLD { }, SILVER }                               // 3 (el cuerpo de GOLD no cuenta)
    record Item(String name) {}                                  // 4
    @interface Tag {}                                            // 5
    static abstract class Base {}                                // 6

    void run() {
        class Local {}                                           // 7
        Runnable r = new Runnable() { public void run() {} };    // 8
        Runnable l = () -> {};                                   // una lambda no es un tipo: no cuenta
    }
}

C(p) = 8. Los demás recuentos de esta familia salen del mismo código: 1 clase abstracta (Base), 1 enumerado, 2 interfaces (Pricing y Tag, porque una anotación es una interfaz), 1 anotación, 1 clase anónima, 4 clases concretas (Shop, Item, Local y la anónima) y 1 clase de nivel superior (Shop).

Cómo interpretarla

No hay un valor bueno ni malo, y por eso no tiene umbrales. Sirve para:

  • Situar el tamaño de un módulo o un proyecto en una unidad más cercana al diseño que las líneas de código.
  • Normalizar otras métricas: líneas por clase, métodos por clase o dependencias por clase salen de dividir por este número.
  • Comparar paquetes: un paquete con muchos más tipos que el resto suele ser candidato a dividirse.

Para saber de qué clase son los tipos, compáralo con sus partes: «clases abstractas», «concretas», «interfaces» y «enumerados». En Stau Metro esas cuatro suman exactamente C.

Relación con otras métricas

En las herramientas

Stau Metro (NumClassesPackage, NumClassesRecursivePackage, NumClassesModule, NumClassesProject). Recorre los ficheros Java del ámbito analizado y cuenta cada declaración de tipo, sea cual sea su clase, a cualquier profundidad: interfaces, enumerados, anotaciones, records, clases anidadas, locales y anónimas. No cuenta los parámetros de tipo ni los cuerpos de las constantes de un enumerado (GOLD { } en el ejemplo), que forman parte de su enumerado. Los tests y la producción cuentan por igual. Cada fichero se asigna al paquete y al módulo que lo contienen, de modo que una clase anidada o anónima cuenta en el paquete de su fichero.

  • Paquete. Solo aparecen los paquetes que declaran al menos un tipo. Un paquete que solo contiene subpaquetes no tiene fila.
  • Paquete recursivo (RecursiveCount). Suma los tipos del paquete y los de todos sus subpaquetes, de modo que p incluye lo de p.q. El paquete por defecto (el que no tiene nombre) solo recibe sus propios tipos, no los totales de los demás.
  • Módulo. Una fila por módulo que contiene algún tipo del ámbito.
  • Proyecto. Una sola fila, que existe aunque valga 0.

Kotlin: no cuenta; esta métrica solo ve código Java.

SonarQube. Su métrica classes es «el número de clases (incluidas las clases anidadas, interfaces, enumerados, anotaciones, mixins, extensiones y tipos de extensión)», según su documentación de métricas.

JDepend. Cuenta, por paquete, las clases concretas, las abstractas y las interfaces. Su documentación describe el recuento como un indicador de la extensibilidad del paquete.

Referencias