Java 可选参数

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

1. Method overloading.

   void foo(字符串a，整数b){

   void foo(String A){ foo(a，0)；//这里0是b的默认值 }

   foo("a"，2)； foo("a")；

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

1. Varargs.个

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.为了解决前面方法的局限性，您可以允许空值，然后分析方法体中的每个参数:

   void foo(字符串a，整数b，整数c){ b=b！=NULL？B:0； c=c！=null？C:0； //. }

   foo("a"，NULL，2)；

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

1. Optional class.此方法类似于NULL，但对具有默认值的参数使用Java 8可选类:

   void foo(字符串a，可选bOpt){

   foo("a"，第(2)项中的可选项)；

   可选使方法契约对于调用者是显式的，但是，人们可能会发现这样的签名过于冗长.

   更新:Java8包含开箱即用的java.util.Optional类，因此在Java8中没有必要因为这个特殊原因使用番石榴.不过，方法名有点不同.

2. Builder pattern.构建器模式用于构造函数，并通过引入单独的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(映射<；字符串，对象>；参数){ String a=""； 整数b=0； if(parameters.include sKey("a")){ 如果(！(parameters.get("a")instanceof Integer)){ 抛出新的IllegalArgumentException(".")； } a=(整数)参数s.get("a")； } if(parameters.include sKey("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"));
   

请注意，您可以结合这些方法中的任何一种来实现理想的结果.