web-dev-qa-db-fra.com

Java constructeur / méthode avec paramètres optionnels?

Duplicata possible:
paramètres optionnels Java

Je sais qu'en PHP si vous voulez appeler une fonction avec moins de paramètres, vous déclarez la fonction comme:

function foo(int param1, int param2 = "2");

et maintenant je peux appeler foo(2) et param2 sera réglé sur 2.

J'ai essayé de le faire dans un constructeur Java mais il semble que ce ne soit pas possible. Y a-t-il un moyen de le faire ou je dois simplement déclarer deux constructeurs?

Merci!

javaconstructor
32
tgm_rr

Java n'a pas le concept de paramètres optionnels avec des valeurs par défaut dans les constructeurs ou dans les méthodes. Vous êtes essentiellement coincé avec une surcharge. Cependant, vous enchaînez facilement les constructeurs, vous n'avez donc pas besoin de répéter le code:

public Foo(int param1, int param2)
{
    this.param1 = param1;
    this.param2 = param2;
}

public Foo(int param1)
{
    this(param1, 2);
}
95
Jon Skeet

Java ne prend pas en charge les paramètres par défaut. Vous aurez besoin de deux constructeurs pour faire ce que vous voulez.

Une alternative s'il y a beaucoup de valeurs possibles avec des valeurs par défaut est d'utiliser le modèle Builder, par lequel vous utilisez un objet d'assistance avec des setters.

par exemple.

   public class Foo {
     private final String param1;
     private final String param2;

     private Foo(Builder builder) {
       this.param1 = builder.param1;
       this.param2 = builder.param2;
     }
     public static class Builder {
       private String param1 = "defaultForParam1";
       private String param2 = "defaultForParam2";

       public Builder param1(String param1) {
         this.param1 = param1;
         return this;
       }
       public Builder param2(String param1) {
         this.param2 = param2;
         return this;
       }
       public Foo build() {
         return new Foo(this);
       }
     }
   }

ce qui vous permet de dire:

Foo myFoo = new Foo.Builder().param1("myvalue").build();

qui aura une valeur par défaut pour param2.

17
Simon Nickerson

Vous pouvez le simuler à l'aide de varargs, mais vous devriez alors le vérifier pour trop d'arguments.

public void foo(int param1, int ... param2)
{
   int param2_
   if(param2.length == 0)
      param2_ = 2
   else if(para2.length == 1)
      param2_ = param2[0]
   else
      throw new TooManyArgumentsException(); // user provided too many arguments,

   // rest of the code
}

Cependant, cette approche n'est pas un bon moyen de le faire, il est donc préférable d'utiliser la surcharge.

7
reader_1000

Vous pouvez utiliser varargs pour les paramètres facultatifs:

public class Booyah {
    public static void main(String[] args) {
        woohoo(1);
        woohoo(2, 3);
    }
    static void woohoo(int required, Integer... optional) {
        Integer lala;
        if (optional.length == 1) {
            lala = optional[0];
        } else {
            lala = 2;
        }
        System.out.println(required + lala);
    }
}

Il est également important de noter l'utilisation de Integer sur int. Integer est n wrapper autour de la primitive int , ce qui permet de faire des comparaisons avec null si nécessaire.

3
fny

Vous ne pouvez pas avoir d'arguments facultatifs qui prennent par défaut une certaine valeur en Java. La chose la plus proche de ce dont vous parlez est Java varargs grâce auquel vous pouvez passer un nombre arbitraire d'arguments (du même type) à une méthode.

0
Ashkan Aryan

Pourquoi est ce que tu veux faire ça?

Cependant, vous pouvez le faire:

public void foo(int param1)
{
    int param2 = 2;
    // rest of code
}

ou:

public void foo(int param1, int param2)
{
    // rest of code
}

public void foo(int param1)
{
    foo(param1, 2);
}
0
Eng.Fouad