如何在Java中使用可选参数?什么规范支持可选参数?

问题

如何在Java中使用可选参数?什么规范支持可选参数?


#1 热门回答(1377 赞)

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

  • 方法重载。 void foo(String a,Integer b){
        // ...
    }

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

foo(“a”,2);
FOO( “A”);
 这种方法的一个限制是,如果你有两个相同类型的可选参数并且可以省略其中任何一个,则它不起作用。

  • Varargs。 a)所有可选参数的类型相同:void foo(String a,Integer ... b){
        整数b1 = b.length> 0? b [0]:0;
        整数b2 = b.length> 1? b [1]:0;
        // ...
    }

FOO( “A”);
foo(“a”,1,2);
 b)可选参数的类型可能不同:void foo(String a,Object ... b){
    整数b1 = 0;
    字符串b2 =“”;
    if(b.length> 0){
      if(!(b [0] instanceof Integer)){
          抛出新的IllegalArgumentException(“...”);
      }
      b1 =(整数)b [0];
    }
    if(b.length> 1){
        if(!(b [1] instanceof String)){
            抛出新的IllegalArgumentException(“...”);
        }
        b2 =(String)b [1];
        // ...
    }
    // ...
}

FOO( “A”);
foo(“a”,1);
foo(“a”,1,“b2”);
 这种方法的主要缺点是,如果可选参数属于不同类型,则会丢失静态类型检查。此外,如果每个参数具有不同的含义,你需要一些方法来区分它们。

  • 无效。要解决先前方法的限制,你可以允许空值,然后分析方法体中的每个参数:void foo(String a,Integer b,Integer c){
        b = b!= null? b:0;
        c = c!= null? c:0;
        // ...
    }

foo(“a”,null,2);
 现在必须提供所有参数值,但默认值可以为null。

  • 可选课程。此方法类似于null,但对具有默认值的参数使用Java 8 Optional类:void foo(String a,Optional <Integer> bOpt){
        整数b = bOpt.isPresent()? bOpt.get():0;
        // ...
    }

foo(“a”,Optional.of(2));
foo(“a”,可选。<Integer> absent());
 可选为调用者显示方法契约,但是,人们可能会发现这样的签名过于冗长。更新:Java 8包含类java.util.Optional开箱即用,因此在java 8中不需要为此特殊原因使用guava。方法名称有点不同。

  • 生成器模式。构建器模式用于构造函数,并通过引入单独的Builder类来实现:class Foo {
         private final String a;
         私人决赛整数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;
     归还这个;
   }

   FooBuilder setB(整数b){
     this.b = b;
     归还这个;
   }

   Foo build(){
     返回新的Foo(a,b);
   }
 }

 Foo foo = new FooBuilder()。setA(“a”)。build();

  • Map 。当参数的数量太大且通常使用默认值时,你可以将方法参数作为其名称/值的映射传递:void foo(Map <String,Object> parameters){
        字符串a =“”;
        整数b = 0;
        if(parameters.containsKey(“a”)){
            if(!(parameters.get(“a”)instanceof Integer)){
                抛出新的IllegalArgumentException(“...”);
            }
            a =(整数)parameters.get(“a”);
        }
        if(parameters.containsKey(“b”)){
            // ...
        }
        // ...
    }

foo(ImmutableMap。<String,Object> of(
    “a”,“a”,
    “b”,2,
    “d”,“value”));

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


#2 热门回答(403 赞)

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

private boolean defaultOptionalFlagValue = true;

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

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

#3 热门回答(93 赞)

你可以使用这样的东西:

public void addError(String path, String key, Object... params) { 
}

params变量是可选的。它被视为可以为对象的可空数组。

奇怪的是,我在文档中找不到任何相关内容,但它确实有效!

这在Java 1.5及更高版本中是“新的”(Java 1.4或更早版本不支持)。

我看到用户bhoot也提到了这一点。