Wie können optionale Parameter in Java simuliert werden?-javaLernprogramm-php.cn

Wie können optionale Parameter in Java simuliert werden?

Mary-Kate Olsen

Freigeben： 2024-12-15 13:54:19

Original

171 Leute haben es durchsucht

How Can Optional Parameters Be Simulated in Java?

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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!