在 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. 空值。若要解决先前方法的局限性，可以允许 null 值，然后分析方法主体中的每个参数：

   void foo（String a， Integer b， Integer c） { b = b ！= null ？
   b ： 0; c = c ！= null ？ c ： 0;

   //…
   }

   foo（“a”， null， 2）;

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

1. 可选类。此方法类似于 nulls，但对具有缺省值的参数使用 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. 生成器模式。生成器模式用于构造函数，并通过引入单独的 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. 地图。当参数数量太大并且通常使用大多数默认值时，可以将方法参数作为其名称/值的映射传递：

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

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

网友回答：

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

private boolean defaultOptionalFlagValue = true;

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

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

网友回答：

Java 5.0 有可选参数。只需像这样声明您的函数：

public void doSomething(boolean... optionalFlag) {
    //default to "false"
    //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}

您可以立即致电 或。doSomething();doSomething(true);