Paramètres facultatifs Java

Comment utiliser les parameters facultatifs en Java? Quelle spécification prend en charge les parameters facultatifs?

varargs pourrait le faire (en quelque sorte). Sinon, toutes les variables de la déclaration de la méthode doivent être fournies. Si vous voulez qu’une variable soit facultative, vous pouvez surcharger la méthode en utilisant une signature qui ne nécessite pas le paramètre.

private boolean defaultOptionalFlagValue = true; public void doSomething(boolean optionalFlag) { ... } public void doSomething() { doSomething(defaultOptionalFlagValue); } 

Il existe plusieurs manières de simuler des parameters facultatifs en Java:

  1. Surcharge de méthode.

     void foo(Ssortingng a, Integer b) { //... } void foo(Ssortingng a) { foo(a, 0); // here, 0 is a default value for b } foo("a", 2); foo("a"); 

    L’une des limites de cette approche est qu’elle ne fonctionne pas si vous avez deux parameters optionnels du même type et que l’un d’eux peut être omis.

  2. Varargs.

    a) Tous les parameters facultatifs sont du même type:

     void foo(Ssortingng a, Integer... b) { Integer b1 = b.length > 0 ? b[0] : 0; Integer b2 = b.length > 1 ? b[1] : 0; //... } foo("a"); foo("a", 1, 2); 

    b) Les types de parameters facultatifs peuvent être différents:

     void foo(Ssortingng a, Object... b) { Integer b1 = 0; Ssortingng b2 = ""; if (b.length > 0) { if (!(b[0] instanceof Integer)) { throw new IllegalArgumentException("..."); } b1 = (Integer)b[0]; } if (b.length > 1) { if (!(b[1] instanceof Ssortingng)) { throw new IllegalArgumentException("..."); } b2 = (Ssortingng)b[1]; //... } //... } foo("a"); foo("a", 1); foo("a", 1, "b2"); 

    Le principal inconvénient de cette approche est que si des parameters optionnels sont de types différents, vous perdez la vérification de type statique. De plus, si chaque paramètre a un sens différent, vous avez besoin d’un moyen de les distinguer.

  3. Nulls Pour répondre aux limitations des approches précédentes, vous pouvez autoriser des valeurs nulles, puis parsingr chaque paramètre dans un corps de méthode:

     void foo(Ssortingng a, Integer b, Integer c) { b = b != null ? b : 0; c = c != null ? c : 0; //... } foo("a", null, 2); 

    Toutes les valeurs d’arguments doivent maintenant être fournies, mais celles par défaut peuvent être nulles.

  4. Classe optionnelle Cette approche est similaire à null, mais utilise la classe Java 8 Facultatif pour les parameters qui ont une valeur par défaut:

     void foo(Ssortingng a, Optional bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.absent()); 

    Facultatif rend un contrat de méthode explicite pour un appelant, cependant, on peut trouver cette signature trop verbeuse.

    Mise à jour: Java 8 inclut la classe java.util.Optional à l’emploi, il n’est donc pas nécessaire d’utiliser guava pour cette raison particulière dans java 8. Le nom de la méthode est cependant un peu différent.

  5. Modèle de constructeur Le modèle de générateur est utilisé pour les constructeurs et est implémenté en introduisant une classe Builder distincte:

      class Foo { private final Ssortingng a; private final Integer b; Foo(Ssortingng a, Integer b) { this.a = a; this.b = b; } //... } class FooBuilder { private Ssortingng a = ""; private Integer b = 0; FooBuilder setA(Ssortingng a) { this.a = a; return this; } FooBuilder setB(Integer b) { this.b = b; return this; } Foo build() { return new Foo(a, b); } } Foo foo = new FooBuilder().setA("a").build(); 
  6. Plans. Lorsque le nombre de parameters est trop grand et que la plupart des valeurs par défaut sont généralement utilisées, vous pouvez passer des arguments de méthode sous forme de carte de leurs noms / valeurs:

     void foo(Map parameters) { Ssortingng a = ""; Integer b = 0; if (parameters.containsKey("a")) { if (!(parameters.get("a") instanceof Integer)) { throw new IllegalArgumentException("..."); } a = (Integer)parameters.get("a"); } if (parameters.containsKey("b")) { //... } //... } foo(ImmutableMap.of( "a", "a", "b", 2, "d", "value")); 

Veuillez noter que vous pouvez combiner ces approches pour obtenir un résultat souhaitable.

Vous pouvez utiliser quelque chose comme ceci:

 public void addError(Ssortingng path, Ssortingng key, Object... params) { } 

La variable params est facultative. Il est traité comme un tableau d’objects nullable.

Bizarrement, je n’ai rien trouvé à ce sujet dans la documentation, mais ça marche!

Ceci est “nouveau” dans Java 1.5 et au-delà (non pris en charge dans Java 1.4 ou version antérieure).

Je vois l’utilisateur bhoot mentionné ci-dessous.

Il existe des parameters facultatifs avec Java 5.0. Déclarez simplement votre fonction comme ceci:

 public void doSomething(boolean... optionalFlag) { //default to "false" //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false; } 

vous pouvez appeler avec doSomething(); ou doSomething(true); à présent.

Malheureusement, Java ne supporte pas directement les parameters par défaut.

Cependant, j’ai écrit un ensemble d’annotations JavaBean, et l’une d’entre elles prend en charge les parameters par défaut, tels que:

 protected void process( Processor processor, Ssortingng item, @Default("Processor.Size.LARGE") Size size, @Default("red") Ssortingng color, @Default("1") int quantity) { processor.process(item, size, color, quantity); } public void report(@Default("Hello") Ssortingng message) { System.out.println("Message: " + message); } 

Le processeur d’annotations génère les surcharges de la méthode pour prendre correctement en charge cela.

Voir http://code.google.com/p/javadude/wiki/Annotations

Exemple complet à l’ adresse http://code.google.com/p/javadude/wiki/AnnotationsDefaultParametersExample

Il n’y a pas de parameters facultatifs en Java. Ce que vous pouvez faire, c’est surcharger les fonctions, puis transmettre les valeurs par défaut.

 void SomeMethod(int age, Ssortingng name) { // } // Overload void SomeMethod(int age) { SomeMethod(age, "John Doe"); } 

VarArgs et la surcharge ont été mentionnés. Une autre option est un modèle de générateur, qui ressemble à ceci:

  MyObject my = new MyObjectBuilder().setParam1(value) .setParam3(otherValue) .setParam6(thirdValue) .build(); 

Bien que ce modèle soit le plus approprié lorsque vous avez besoin de parameters facultatifs dans un constructeur.

Dans JDK> 1.5, vous pouvez l’utiliser comme ceci;

 public class NewClass1 { public static void main(Ssortingng[] args) { try { someMethod(18); // Age : 18 someMethod(18, "John Doe"); // Age & Name : 18 & John Doe } catch (Exception e) { e.printStackTrace(); } } static void someMethod(int age, Ssortingng... names) { if (names.length > 0) { if (names[0] != null) { System.out.println("Age & Name : " + age + " & " + names[0]); } } else { System.out.println("Age : " + age); } } } 

Cela dépend de ce que vous voulez réaliser, varargs ou la surcharge de la méthode devrait résoudre la plupart des scénarios.

mais gardez à l’esprit de ne pas trop utiliser la surcharge de méthode. cela apporte de la confusion.

Version courte :

En utilisant trois points :

 public void foo(Object... x) { Ssortingng first = x.length > 0 ? (Ssortingng)x[0] : "Hello"; int duration = x.length > 1 ? Integer.parseInt((Ssortingng) x[1]) : 888; } foo("Hii", ); foo("Hii", 146); 

(basé sur la réponse de @ VitaliiFedorenko)

Vous pouvez faire quelque chose en utilisant une méthode de surcharge comme celle-ci.

  public void load(Ssortingng name){ } public void load(Ssortingng name,int age){} 

Vous pouvez aussi utiliser l’annotation @Nullable

 public void load(@Nullable Ssortingng name,int age){} 

Passez simplement null en premier paramètre.

Si vous passez la même variable de type, vous pouvez l’utiliser

 public void load(Ssortingng name...){} 

La surcharge est correcte, mais s’il y a beaucoup de variables qui nécessitent une valeur par défaut, vous allez vous retrouver avec:

 public void methodA(A arg1) { } public void methodA( B arg2,) { } public void methodA(C arg3) { } public void methodA(A arg1, B arg2) { } public void methodA(A arg1, C arg3) { } public void methodA( B arg2, C arg3) { } public void methodA(A arg1, B arg2, C arg3) { } 

Je suggère donc d’utiliser l’argument de variable fourni par Java. Voici un lien pour l’explication.

Java prend désormais en charge les options en 1.8, je suis bloqué avec la programmation sur Android, donc j’utilise les valeurs NULL jusqu’à ce que je puisse refactoriser le code pour utiliser les types optionnels.

 Object canBeNull() { if (blah) { return new Object(); } else { return null; } } Object optionalObject = canBeNull(); if (optionalObject != null) { // new object returned } else { // no new object returned } 

Vous pouvez utiliser une classe qui fonctionne comme un générateur pour contenir vos valeurs optionnelles comme celle-ci.

 public class Options { private Ssortingng someSsortingng = "default value"; private int someInt= 0; public Options setSomeSsortingng(Ssortingng someSsortingng) { this.someSsortingng = someSsortingng; return this; } public Options setSomeInt(int someInt) { this.someInt = someInt; return this; } } public static void foo(Consumer consumer) { Options options = new Options(); consumer.accept(options); System.out.println("someSsortingng = " + options.someSsortingng + ", someInt = " + options.someInt); } 

Utiliser comme

 foo(o -> o.setSomeSsortingng("something").setSomeInt(5)); 

La sortie est

 someSsortingng = something, someInt = 5 

Pour ignorer toutes les valeurs facultatives, vous devez l’appeler comme foo(o -> {}); ou si vous préférez, vous pouvez créer une seconde méthode foo() qui ne prend pas les parameters facultatifs.

Grâce à cette approche, vous pouvez spécifier des valeurs facultatives dans n’importe quel ordre sans aucune ambiguïté. Vous pouvez également avoir des parameters de différentes classes contrairement à varargs. Cette approche serait encore meilleure si vous pouviez utiliser les annotations et la génération de code pour créer la classe Options.

Les arguments par défaut ne peuvent pas être utilisés en Java et en C #. Où en C ++ et Python, nous pouvons les utiliser.

En Java, il faut utiliser 2 méthodes (fonctions) au lieu d’une avec les parameters par défaut.

Exemple:

 Stash(int size); Stash(int size, int initQuantity); 

http://parvindersingh.webs.com/apps/forums/topics/show/8856498-java-how-to-set-default-parameters-values-like-c-

Nous pouvons créer des parameters facultatifs en surchargeant la méthode ou en utilisant DataType …

| * | Surcharge de méthode:

 RetDtaTyp NamFnc(Ssortingng NamPsgVar) { // |* CodTdo *| return RetVar; } RetDtaTyp NamFnc(Ssortingng NamPsgVar) { // |* CodTdo *| return RetVar; } RetDtaTyp NamFnc(int NamPsgVar1, Ssortingng NamPsgVar2) { // |* CodTdo *| return RetVar; } 

Le plus simple est

| * | DataType … peut être un paramètre facultatif

 RetDtaTyp NamFnc(int NamPsgVar, Ssortingng... SrgOpnPsgVar) { if(SrgOpnPsgVar.length == 0) SrgOpnPsgVar = DefSrgVar; // |* CodTdo *| return RetVar; }