Mise en forme de plusieurs arguments passés à une fonction en Java

Souvent le nombre d'arguments passés à une fonction peut être importante. Considérons le cas suivant:

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

Est-il une ligne directrice dans Java qui offre un moyen d'aligner les arguments? Côté tous les arguments dans une ligne ne serait pas assez.

source d'informationauteur Leonid

14

Selon la Java de Sun conventions de codageparagraphe 4.1 "les Lignes de conditionnement":
Lorsqu'une expression ne tient pas sur une seule ligne, de le briser en fonction de ces principes généraux:
- Pause après une virgule.
- Pause avant un opérateur.
- Préfèrent augmenter le niveau de sauts de niveau inférieur, sauts de.
- Aligner sur la nouvelle ligne avec le début de l'expression au même niveau sur la ligne précédente.
- Si les règles ci-dessus conduisent à code source de confusion ou de code qui est écrasée contre la marge de droite, juste en retrait de 8 places de la place.
Le document comprend également quelques exemples pour les appels de méthode:
```
function(longExpression1, longExpression2, longExpression3,
         longExpression4, longExpression5);

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

Quand je dois appeler une méthode comme ceci, je tiens à mettre les arguments sur leur propre ligne, comme ceci:
```
final int result = calculate (
    dataManager.getLastUpdate().getNumberOfChildren(),
    dataManager.getLastUpdate().getNumberOfParents(),
    dataManager.getLastUpdate().getNumberOfGrandChildren(),
    milliseconds,
    somethingelse
);
```
Évidemment, c'est une question de préférence personnelle, mais si vous travaillez avec d'autres personnes sur le code, essayer de se conformer aux conventions déjà établies.

Je vais mettre mon petit grain de sable ici, il y a longtemps un développeur nommé Esteban
m'a suggéré ce type de mise en forme, que j'1er pensais que c'était laid
après un moment, pas d'autre façon de faire est assez agréable pour moi:

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

Je trouve ça très clair, très facile à ajouter/supprimer des arguments nouveaux,
le nombre d'arguments clairs, un seul argument par ligne, l'appel de la méthode la fin vraiment clair,
etc...

Modèle similaire pour la définition de la méthode trop

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

     //MyCode

    }

Et, enfin, le motif est le même pour les appels imbriqués, StringBuilder typicall séquence

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

Le seul problème que j'ai trouvé est que l'IDE formateurs ne laissez jamais cette "virgule au début de" l'approche qui est vraiment intéressant, et beaucoup plus lisible que n'importe quel autre que j'ai essayé.

Espère que ça ajoute quelque chose d'intéressant

Je pourrait affecter les valeurs de retour de la getNumberOf*() les méthodes à variables:

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

1

Se référant à votre exemple, Eclipse et d'autres IDEs format de la façon dont vous avez ci-dessus (1 argument par ligne, tous alignés à gauche) et, généralement, cela semble assez bon.
0

Je suis entièrement d'accord avec votre exemple de disposer d'un argument par ligne, tous alignés sous les uns des autres.

Il le rend très facile à numériser vers le bas de la liste pour voir ce qui est là ou ce qui est manquant.

Il rend également plus facile de documenter les valeurs null comme étant "//id d'utilisateur" ou quelque chose de similaire.

Je trouve qu'il est particulièrement facile à analyser visuellement, plutôt que d'avoir plusieurs lignes de dense de valeurs que l'on peut souvent se ressembler.

Vous devez vous connecter pour publier un commentaire.