Número de parámetros

Actualizado el 15 de noviembre de 2026

Sigla NP
Aspecto «Complejidad»
Se mide en método
Tipo de valor recuento (entero, mínimo 0)
Dirección más alto es peor
Umbrales de referencia aviso por encima de 5, error por encima de 7 (Stau Metro)
Stau Metro NumParameters

En pocas palabras

Cuenta los parámetros que recibe un método: los que hay entre los paréntesis de su declaración. Un método sin parámetros vale 0; void send(String to, String subject, String body) vale 3. Cuantos más parámetros tiene un método, más cuesta llamarlo bien y más probable es que esté haciendo varias cosas a la vez.

Qué mide

Mide el tamaño de la interfaz de un método: cuánta información tiene que darle quien lo llama. Es la medida más directa de un problema de diseño muy conocido, la lista de parámetros larga (long parameter list), que Fowler incluyó entre los «malos olores» del código en Refactoring (1999).

Una lista de parámetros larga causa problemas concretos:

  • Llamadas propensas a errores. Con create(String, String, String, int, int) es fácil intercambiar dos argumentos del mismo tipo; el compilador no lo detecta.
  • Carga de memoria. Quien lee la llamada create("a", "b", null, 0, 3) tiene que ir a la declaración para saber qué es cada valor.
  • Fragilidad. Cada parámetro nuevo obliga a cambiar todas las llamadas.
  • Síntoma de diseño. Muchos parámetros suelen indicar que el método hace demasiado, o que varios valores viajan siempre juntos y deberían ser un objeto.

Para quien empieza. Un parámetro formal es la variable que se declara en la firma (int n en void m(int n)); un argumento es el valor que se pasa al llamar (m(5)). Esta métrica cuenta los primeros.

Cómo se calcula

Se cuenta 1 por cada parámetro declarado en la lista de parámetros del método. No importan ni los tipos ni las anotaciones ni si el parámetro se usa. Un parámetro de longitud variable (String... names) cuenta como uno, aunque reciba muchos valores al llamarlo.

La definición no tiene un autor de referencia: es un recuento directo de la firma. Lo que varía entre herramientas es a qué métodos se aplica (constructores, métodos que sobrescriben otro, métodos anotados) y cuál es el umbral.

Ejemplo

interface Billing {
    // Antes: seis parámetros
    Invoice issue(String customerName, String customerTaxId, String street,   // +3
                  String city, LocalDate date, BigDecimal amount);           // +3
}

Total: 6. Supera el umbral de aviso de Stau Metro (5) sin llegar al de error (7). Los cuatro parámetros de tipo String se pueden intercambiar sin que el compilador proteste, y todos describen al cliente: su nombre, su identificador fiscal y su dirección. Agruparlos da:

record Address(String street, String city) {}
record Customer(String name, String taxId, Address address) {}

interface Billing {
    Invoice issue(Customer customer, LocalDate date, BigDecimal amount);     // +3
}

Total: 3. El método no ha perdido información; la ha recibido en una forma con nombre.

Cómo interpretarla

Valor Lectura habitual
0-3 Interfaz pequeña
4-5 Aceptable; conviene preguntarse si algunos parámetros van siempre juntos
6-7 Difícil de usar bien: candidato a refactorizar
Más de 7 Casi siempre un problema de diseño

La tabla es una orientación construida sobre estos límites publicados:

  • Stau Metro: aviso por encima de 5, error por encima de 7.
  • Checkstyle (ParameterNumber) y SonarQube (regla S107 de Java): máximo por defecto de 7.
  • PMD (ExcessiveParameterList): informa a partir de 10.
  • Robert C. Martin, en Clean Code (2008), es más estricto: el número ideal de argumentos es cero, y más de tres «requiere una justificación muy especial».

Qué hacer con un valor alto:

  • Introduce un objeto parámetro (Introduce Parameter Object). Si varios parámetros viajan siempre juntos (un rango de fechas, una dirección), agrúpalos en una clase o un record.
  • Pasa el objeto entero (Preserve Whole Object). Si el método recibe tres campos de un mismo objeto, pásale el objeto.
  • Sustituye el parámetro por una consulta (Replace Parameter with Query). Si el método puede obtener el valor por sí mismo a partir de otro parámetro o de su clase, no hace falta pasárselo.
  • Elimina los parámetros bandera (Remove Flag Argument). Un boolean que cambia el comportamiento suele ser un método que debería ser dos.
  • Divide el método. Si los parámetros se reparten en grupos que se usan por separado, cada grupo puede ser un método.

Cuándo un valor alto es aceptable. Los constructores de objetos de valor y de record que reciben todos sus campos, los constructores que reciben dependencias inyectadas y los métodos que implementan una firma impuesta por un framework o por una interfaz ajena. En estos casos el número dice algo de la clase (tiene muchos campos o muchas dependencias) más que del método.

Ojo. Meter los parámetros en un Map<String, Object> o en un objeto «saco» sin significado baja el valor de la métrica y empeora el código: se pierde la comprobación de tipos y la llamada deja de documentarse a sí misma.

Para profundizar

Qué refactorización elegir. Las cuatro primeras recetas de arriba están en el catálogo de refactorizaciones de Fowler (segunda edición). La diferencia entre las dos más usadas es de dónde salen los valores: Introduce Parameter Object crea una abstracción nueva para datos que aún no la tienen; Preserve Whole Object aprovecha una que ya existe, a cambio de acoplar el método a un tipo más grande del que necesita.

El parámetro como acoplamiento. Cada parámetro de un tipo del dominio es una dependencia del método. Reducir el número de parámetros pasando el objeto entero puede aumentar el acoplamiento; reducirlo con un objeto parámetro nuevo, no. Por eso conviene leer esta métrica junto a las de «acoplamiento».

Formas de falsear la métrica. Además del Map genérico, los builders y los métodos setter encadenados reducen el número de parámetros de una llamada sin reducir la información que hay que suministrar. Pueden ser una buena solución (hacen las llamadas legibles y los valores opcionales explícitos), pero desplazan el problema a otra parte: el objeto que se construye.

Relación con otras métricas

  • «Número promedio de parámetros» (OPavg): la media de esta métrica sobre los métodos y constructores de una clase. Sirve para comparar clases; esta, para encontrar el método concreto.
  • «Número de parámetros de tipo» (NTP): cuenta los parámetros genéricos (<T, R>), no los de valor. Se confunden por el nombre.
  • «Complejidad ciclomática» (v(G)): un método con muchos parámetros suele tener también muchas decisiones, porque tiene que tratar muchas combinaciones de entrada; leídas juntas señalan los métodos que hacen demasiado.
  • «Tamaño de la clase (atributos)» (CSA): un constructor con muchos parámetros casi siempre corresponde a una clase con muchos campos.

En las herramientas

Stau Metro (NumParameters, a nivel de método). Cuenta los parámetros de la lista de parámetros. Se calcula para todos los métodos, incluidos los constructores, los métodos abstractos y los métodos de las interfaces. Los métodos de las clases anónimas y locales declaradas dentro del cuerpo de un método no tienen valor propio, y sus parámetros no se suman al método que las contiene; los de una clase anónima escrita en el inicializador de un campo sí tienen valor propio. Los parámetros de las lambdas no cuentan: una lambda no es un método. Los métodos que el compilador genera sin que aparezcan en el código (los accesores de un record, values() de un enumerado) no se miden.

Checkstyle (ParameterNumber). Comprueba métodos y constructores, con un máximo por defecto de 7. Con ignoreOverriddenMethods no comprueba los métodos anotados con @Override, y con ignoreAnnotatedBy, los que llevan alguna de las anotaciones indicadas. Quitando CTOR_DEF de tokens, deja fuera los constructores.

PMD (ExcessiveParameterList). Informa de los métodos cuyo número de parámetros es igual o mayor que minimum, 10 por defecto.

SonarQube (regla S107 del analizador de Java). Máximo de 7 parámetros por defecto, con un máximo propio para los constructores (constructorMax, también 7). No informa de los métodos que sobrescriben otro, ni de los que llevan ciertas anotaciones de frameworks (por ejemplo @Inject, @JsonCreator o @Autowired); tampoco analiza los record.

MetricsReloaded (NP). Cuenta los parámetros de cada método igual que Stau Metro.

Referencias