Comment simuler les paramètres facultatifs en Java ?

Simulation des paramètres facultatifs en Java

Java ne prend pas en charge nativement les paramètres facultatifs. Cependant, il existe différentes manières de simuler cette fonctionnalité.

Surcharge de méthodes

La surcharge des méthodes avec différentes listes de paramètres vous permet de spécifier des paramètres facultatifs en fournissant une valeur par défaut dans certains méthodes. Par exemple :

void foo(String a, Integer b) {
    //...
}

void foo(String a) {
    foo(a, 0); // Here, 0 is the default value for b
}

foo("a", 2);
foo("a");  // Uses the default value for b

Cependant, cette approche devient lourde s'il existe plusieurs paramètres facultatifs du même type.

Varargs

Les Varargs peuvent être utilisé pour simuler des paramètres facultatifs si tous les paramètres facultatifs sont du même type :

void foo(String 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);

Alternativement, varargs peut également être utilisé avec différents types de paramètres, mais cela nécessite des vérifications supplémentaires :

void foo(String a, Object... b) {
    Integer b1 = 0;
    String 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 String)) { 
            throw new IllegalArgumentException("...");
        }
        b2 = (String)b[1];
        //...
    }
    //...
}

foo("a");
foo("a", 1);
foo("a", 1, "b2");  // Note that the order of arguments matters

Nulls

L'utilisation de valeurs nulles pour les paramètres facultatifs est une autre option :

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

foo("a", null, 2);

Cependant, cela nécessite de vérifier les valeurs nulles dans la méthode body.

Classe facultative

Java 8 a introduit la classe facultative, qui peut être utilisée pour représenter des valeurs facultatives :

void foo(String a, Optional<Integer> bOpt) {
    Integer b = bOpt.isPresent() ? bOpt.get() : 0;
    //...
}

foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());

Modèle de constructeur

Le modèle de constructeur est une autre approche, généralement utilisée en conjonction avec constructeurs :

class Foo {
    private final String a; 
    private final Integer b;

    Foo(String a, Integer b) {
      this.a = a;
      this.b = b;
    }

    //...
}

class FooBuilder {
  private String a = ""; 
  private Integer b = 0;
  
  FooBuilder setA(String 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();

Maps

Lorsque vous traitez un grand nombre de paramètres facultatifs, utiliser une carte pour les transmettre sous forme de paires nom-valeur peut être pratique :

void foo(Map<String, Object> parameters) {
    String 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.<String, Object>of(
    "a", "a",
    "b", 2, 
    "d", "value")); 

Dans Java 9, accéder aux valeurs des paramètres à partir d'une carte est devenu plus facile :

// ...
static <T> T getParm(Map<String, Object> map, String key, T defaultValue) {
  return (map.containsKey(key)) ? (T) map.get(key) : defaultValue;
}
// ...

void foo(Map<String, Object> parameters) {
  String a = getParm(parameters, "a", "");
  int b = getParm(parameters, "b", 0);
  // ...
}

foo(Map.of("a","a",  "b",2,  "d","value"));

Ces approches fournissent différentes options de simulation des paramètres facultatifs en Java, vous permettant de choisir la méthode la plus adaptée à vos besoins spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!