Java中如何模拟可选参数？

在 Java 中模拟可选参数

Java 本身不支持可选参数。但是，有多种方法可以模拟此功能。

方法重载

使用不同参数列表重载方法允许您通过在某些参数中提供默认值来指定可选参数。方法。例如：

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

但是，如果存在多个相同类型的可选参数，这种方法会变得很麻烦。

Varargs

Varargs 可以是如果所有可选参数都相同，则用于模拟可选参数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);

或者，可变参数也可以与不同的参数类型一起使用，但这需要额外的检查：

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

对可选参数使用空值是另一种情况option:

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

foo("a", null, 2);

但是，这需要检查方法体中的空值。

Optional 类

Java 8 引入了Optional 类，可用于表示可选值：

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模式

构建器模式是另一种方法，通常与构造函数结合使用：

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

当处理大量可选参数，使用映射将它们作为名称-值对传递可以方便：

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>

在 Java 9 中，从映射访问参数值变得​​更加容易：

// ...
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>

这些方法为在 Java 中模拟可选参数提供了不同的选项，允许您选择最适合您特定需求的方法。

以上是Java中如何模拟可选参数？的详细内容。更多信息请关注PHP中文网其他相关文章！