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

有几种方法可以模拟 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"));
   

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

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

private boolean defaultOptionalFlagValue = true;

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

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