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

Question

什么规范支持可选参数？

Answer 1

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

1. 方法重载。

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

   void foo(String 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. Nulls。要解决以前方法的局限性，您可以允许 null 值，然后分析方法主体中的每个参数:

   void foo(String a, Integer b, Integer c) {b = b != 空？乙:0；c = c != 空？ c:0；//...}

   foo("a", null, 2);

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

1. 可选类。这种方法类似于空值，但对具有默认值的参数使用 Java 8 可选类:

   void foo(String a, 可选 bOpt) {整数 b = bOpt.isPresent() ？ bOpt.get() : 0;//...}

   foo("a", Optional.of(2));foo("a", Optional.absent());

   Optional 使调用者的方法契约明确，但是，人们可能会发现这样的签名过于冗长。

   更新:Java 8 包含开箱即用的 java.util.Optional 类，因此在 Java 8 中出于这个特殊原因不需要使用 guava。方法名称是不过有点不一样。

2. Builder模式。builder模式用于构造器，通过引入一个单独的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();
   

3. Maps。当参数数量过多并且通常使用大多数默认值时，您可以将方法参数作为其名称/值的映射传递:

   void foo(Map 参数) {字符串 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. of(“一个”，“一个”，"b", 2,"d", "值"));

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

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