Formateo de múltiples argumentos pasados ​​a una función en Java

Question

A menudo, el número de argumentos pasados ​​a una función puede ser grande. Considere el siguiente caso:

calculate(dataManager.getLastUpdate().getNumberOfChildren(), 
      dataManager.getLastUpdate().getNumberOfParents(), 
      dataManager.getLastUpdate().getNumberOfGrandChildren(), 
      long milliseconds, 
      int somethingelse) 

¿Hay una guía en Java que ofrece una manera de alinear los argumentos? Ajustar todos los argumentos en una línea no se vería bonito.

Answer 1

De acuerdo con los Sun's Java coding conventions, párrafo 4.1 "Líneas de embalaje":

Cuando una expresión no cabe en una sola línea, romperlo acuerdo con estos principios generales:

• descanso después de una coma.
• Romper ante un operador.
• Prefieren descansos de nivel superior a descansos de nivel inferior.
• Alinea la nueva línea con el comienzo de la expresión en el mismo nivel en la línea anterior.
• Si las reglas anteriores conducen a un código confuso o al código aplastado contra el margen derecho, solo sangría 8 espacios en su lugar.

El documento también incluye algunos ejemplos de llamadas de método:

function(longExpression1, longExpression2, longExpression3, 
     longExpression4, longExpression5); 

var = function1(longExpression1, 
       function2(longExpression2, 
          longExpression3)); 

Answer 2

Refiriéndose a su ejemplo, Eclipse y otros IDE formato a la forma que tiene encima (1 argumento por línea, todo alineado a la izquierda) y por lo general eso se ve bastante bien.

Answer 3

Cuando tengo que llamar a un método como este me gusta poner los argumentos en su propia línea, así:

final int result = calculate (
    dataManager.getLastUpdate().getNumberOfChildren(), 
    dataManager.getLastUpdate().getNumberOfParents(), 
    dataManager.getLastUpdate().getNumberOfGrandChildren(), 
    milliseconds, 
    somethingelse 
); 

Obviamente, esto es una preferencia personal, pero si usted está trabajando con otros en código, intente ajustarse a las convenciones ya establecidas.

Answer 4

podría asignar los valores de retorno de la getNumberOf *() para variables:

SomeObject lastUpdate = dataManager.getLastUpdate(); 
int children = lastUpdate.getNumberOfChildren(); 
int parents = lastUpdate.getNumberOfParents(); 
int grandChildren = lastUpdate.getNumberOfGrandChildren(); 
calculate(children, parents, grandChildren, milliseconds, somethingelse); 

Answer 5

Voy a poner mi granito de arena, aquí hace mucho tiempo, algunos desarrollador llamado Esteban me sugirió este tipo de formateo, que primero pensó que era fea después de un tiempo hay otra manera de hacerlo es lo suficientemente agradable para mí:

final int result = calculate (
    dataManager.getLastUpdate().getNumberOfChildren() 
    , dataManager.getLastUpdate().getNumberOfParents() 
    , dataManager.getLastUpdate().getNumberOfGrandChildren() 
    , long milliseconds 
    , int somethingelse 
    ); 

me parece muy claro, muy fácil de añadir/eliminar nuevos argumentos, t el n. ° de argumentos es claro, solo un argumento por línea, el método call final es muy claro, etc ...

patrón similar para definir el método demasiado

public int calculate(
    final int numberOfChildren 
    , final int numberOfParents 
    , final int numberOfGrandChildren 
    , final long milliseconds 
    , final int somethingelse 
    ) throws CalucalteExceptio { 

    // MyCode 

    } 

Y finalmente mismo patrón para llamadas anidadas, StringBuilder typicall secuencia

StringBuilder sb = new StringBuilder() 
     .append('Children #').append(numberOfChildren).append(NL) 
     .append('Parents #').append(numberOfParents).append(NL) 
     .append('GrandChildren #').append(numberOfGrandChildren).append(NL) 
     ; 

El único problema que encontramos es que los formateadores IDE nunca permita que este 'coma al principio 'enfoque que es realmente interesante, y mucho más legible que cualquier otro que he probado.

espero que añade algo interesante

Answer 6

estoy totalmente de acuerdo con su ejemplo de tener un argumento por línea, todos alineados uno debajo del otro.

Hace que sea muy fácil escanear la lista para ver qué hay o qué falta.

También hace que sea más fácil documentar los valores nulos como "// id de usuario" o algo similar.

Me parece particularmente fácil de analizar visualmente, en lugar de tener varias líneas largas de valores densamente empaquetados que a menudo se parecen.