如何在 Java 中使用可选参数?

2022-08-31 04:00:30

什么规格支持可选参数?


答案 1

有几种方法可以模拟 Java 中的可选参数:

  1. 方法重载。

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

    void foo(String a) { foo(a, 0); // 这里,0 是 b } 的默认值

    foo(“a”, 2);foo(“a”);

此方法的局限性之一是,如果您有两个相同类型的可选参数,并且可以省略其中任何一个参数,则此方法不起作用。

  1. 瓦拉格斯。

a) 所有可选参数的类型相同:

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

b) 可选参数的类型可能不同:

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

此方法的主要缺点是,如果可选参数的类型不同,则将丢失静态类型检查。此外,如果每个参数具有不同的含义,则需要一些方法来区分它们。

  1. 空值。为了解决上述方法的局限性,您可以允许空值,然后分析方法主体中的每个参数:

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

    foo(“a”, null, 2);

现在必须提供所有参数值,但默认参数值可能为 null。

  1. 可选类。此方法类似于 null,但对具有缺省值的参数使用 Java 8 Optional 类:

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

    foo(“a”, Optional.of(2));foo(“a”, Optional.absent());

    Optional 使调用方显式方法协定,但是,人们可能会发现这样的签名太冗长。

    更新:Java 8 包含开箱即用的类,因此在 Java 8 中,出于这个特殊原因,没有必要使用番石榴。不过,方法名称略有不同。java.util.Optional

  2. 生成器模式。生成器模式用于构造函数,并通过引入单独的生成器类来实现:

    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();
    
  3. 地图。当参数数量太大并且通常使用大多数默认值时,可以将方法参数作为其名称/值的映射传递:

    void foo(Map<String, Object> parameters) { String a = “”;整数 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”));

    在Java 9中,这种方法变得更容易:

    @SuppressWarnings("unchecked")
    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);
      // d = ...
    }
    
    foo(Map.of("a","a",  "b",2,  "d","value"));
    

请注意,您可以结合使用这些方法中的任何一种来获得理想的结果。


答案 2

varargs可以做到这一点(在某种程度上)。除此之外,必须提供方法声明中的所有变量。如果希望变量是可选的,则可以使用不需要参数的签名重载该方法。

private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) {
    ...
}

public void doSomething() {
    doSomething(defaultOptionalFlagValue);
}