Wie können optionale Parameter in Java simuliert werden?

Simulieren optionaler Parameter in Java

Java unterstützt optionale Parameter nicht nativ. Es gibt jedoch verschiedene Möglichkeiten, diese Funktionalität zu simulieren.

Methodenüberladung

Durch das Überladen von Methoden mit unterschiedlichen Parameterlisten können Sie optionale Parameter angeben, indem Sie in einigen Fällen einen Standardwert angeben Methoden. Zum Beispiel:

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

Dieser Ansatz wird jedoch umständlich, wenn mehrere optionale Parameter desselben Typs vorhanden sind.

Varargs

Varargs können sein Wird zur Simulation optionaler Parameter verwendet, wenn alle optionalen Parameter gleich sind Typ:

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);

Alternativ können Varargs auch mit anderen Parametertypen verwendet werden, dies erfordert jedoch zusätzliche Prüfungen:

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

Die Verwendung von Nullwerten für optionale Parameter ist eine weitere Option:

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

foo("a", null, 2);

Dies muss jedoch überprüft werden für Nullwerte im Methodenkörper.

Optionale Klasse

Java 8 führte die optionale Klasse ein, die zur Darstellung optionaler Werte verwendet werden kann:

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

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

Builder-Muster

Das Builder-Muster ist ein weiterer Ansatz, der normalerweise in Verbindung mit verwendet wird Konstruktoren:

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

Beim Umgang mit einer großen Anzahl optionaler Parameter kann die Verwendung einer Map zur Übergabe dieser als Name-Wert-Paare praktisch sein:

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")); </string></string>

In Java 9 wurde der Zugriff auf Parameterwerte aus einer Karte einfacher:

// ...
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"));</string></string></t>

Diese Ansätze bieten verschiedene Optionen zur Simulation optionaler Parameter in Java, sodass Sie die für Ihre spezifischen Anforderungen am besten geeignete Methode auswählen können.

Das obige ist der detaillierte Inhalt vonWie können optionale Parameter in Java simuliert werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!