L'idiome des paramètres nommés en Java

Question

Comment implémenter l'idiome des paramètres nommés en Java ? (en particulier pour les constructeurs)

Je recherche une syntaxe semblable à celle de l'Objective-C et non à celle utilisée dans les JavaBeans.

Un petit exemple de code serait le bienvenu.

Answer 1

Le meilleur idiome Java que j'ai trouvé pour simuler les arguments des mots clés dans les constructeurs est le modèle Builder, décrit dans le document Java efficace 2e édition .

L'idée de base est d'avoir une classe Builder qui possède des setters (mais généralement pas de getters) pour les différents paramètres du constructeur. Il existe également une classe build() méthode. La classe Builder est souvent une classe (statique) imbriquée dans la classe qu'elle sert à construire. Le constructeur de la classe externe est souvent privé.

Le résultat final ressemble à quelque chose comme :

public class Foo {
  public static class Builder {
    public Foo build() {
      return new Foo(this);
    }

    public Builder setSize(int size) {
      this.size = size;
      return this;
    }

    public Builder setColor(Color color) {
      this.color = color;
      return this;
    }

    public Builder setName(String name) {
      this.name = name;
      return this;
    }

    // you can set defaults for these here
    private int size;
    private Color color;
    private String name;
  }

  public static Builder builder() {
      return new Builder();
  }

  private Foo(Builder builder) {
    size = builder.size;
    color = builder.color;
    name = builder.name;
  }

  private final int size;
  private final Color color;
  private final String name;

  // The rest of Foo goes here...
}

Pour créer une instance de Foo, vous écrivez alors quelque chose comme :

Foo foo = Foo.builder()
    .setColor(red)
    .setName("Fred")
    .setSize(42)
    .build();

Les principales mises en garde sont les suivantes :

1. La configuration du modèle est assez verbeuse (comme vous pouvez le voir). Cela n'en vaut probablement pas la peine, sauf pour les classes que vous prévoyez d'instancier à de nombreux endroits.
2. Il n'y a pas de contrôle à la compilation pour vérifier que tous les paramètres ont été spécifiés exactement une fois. Vous pouvez ajouter des vérifications au moment de l'exécution, ou vous pouvez utiliser ceci uniquement pour les paramètres optionnels et faire des paramètres obligatoires des paramètres normaux pour Foo ou le constructeur du Builder. (Les gens ne s'inquiètent généralement pas du cas où le même paramètre est défini plusieurs fois).

Vous pouvez également consulter cet article de blog (pas par moi).

Answer 2

Cela vaut la peine d'être mentionné :

Foo foo = new Foo() {{
    color = red;
    name = "Fred";
    size = 42;
}};

les soi-disant initialisateur à double accolade . Il s'agit en fait d'une classe anonyme avec un initialisateur d'instance.

Answer 3

Vous pouvez également essayer de suivre les conseils de aquí .

int value;
int location;
boolean overwrite;
doIt(value=13, location=47, overwrite=true);

C'est un peu verbeux sur le site d'appel, mais c'est celui qui a le moins de frais généraux.

Answer 4

Si vous utilisez Java 6, vous pouvez utiliser les paramètres variables et l'importation statique pour obtenir un bien meilleur résultat. Vous trouverez plus de détails à ce sujet dans :

http://zinzel.blogspot.com/2010/07/creating-methods-with-named-parameters.html

En bref, vous pourriez avoir quelque chose comme :

go();
go(min(0));
go(min(0), max(100));
go(max(100), min(0));
go(prompt("Enter a value"), min(0), max(100));

Answer 5

Voici une petite variante de la technique présentée dans Effective Java de Joshua Bloch. Ici, j'ai essayé de rendre le code client plus lisible (ou peut-être plus DSL).

/**
 * Actual class for which we want to implement a 
 * named-parameter pseudo-constructor
 */
class Window{
    protected int x, y, width, height;
    protected boolean isResizable;
    protected String title;

    public void show(){
        // Show the window
        System.out.printf("Window \"%s\" set visible.%n",title);
    }

    /**
     * This class is only used to set the parameter values
     */
    static class HavingProperties extends Window{

        public HavingProperties x(int value){
            this.x=value;
            return this;
        }

        public HavingProperties y(int value){
            this.y=value;
            return this;
        }

        public HavingProperties width(int value){
            this.width=value;
            return this;
        }

        public HavingProperties height(int value){
            this.height=value;
            return this;
        }

        public HavingProperties resizable(boolean value){
            this.isResizable=value;
            return this;
        }

        public HavingProperties title(String value){
            this.title=value;
            return this;
        }
    }
}

public class NamedParameterIdiomInAction {
    public static void main(String... args){
        Window window=new Window.HavingProperties().x(10).y(10).width(100).
                height(100).resizable(true).title("My App");
        window.show();
    }
}

Veuillez noter qu'avec cette variante, vous pouvez également donner des noms significatifs à vos pseudo-constructeurs.