java可选参数_Java可选参数

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

可变参数可以做到这一点(在某种程度上)。除此之外，必须提供方法声明中的所有变量。如果你想要一个变量是可选的，你可以使用一个不需要参数的签名来重载方法。private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) {

...

}

public void doSomething() {

doSomething(defaultOptionalFlagValue);

}

有几种方法来模拟Java中的可选参数：重载方法void foo(String a，Integer b){

// ...

}

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

}

foo(“a”，2);

FOO( “A”);

这种方法的局限之一是，如果你有两个相同类型的可选参数，那么它就不起作用，任何参数都可以省略。可变参数。

a)所有可选参数都是相同的类型：void foo(String a，Integer ... b){

整数b1 = b.length＆gt; 0？ b [0]：0;

整数b2 = b.length＆gt; 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);

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

**这个方法类似于nulls，但是对于具有默认值的参数使用Java 8 Optional类：void foo(String a，可选＆lt; Integer＆gt; bOpt){

整数b = bOpt.isPresent()？ bOpt.get()：0;

// ...

}

foo(“a”，Optional.of(2));

foo(“a”，可选。＆lt; Integer＆gt; absent());

可选使一个方法合约明确地为一个调用者，但是，人们可能会发现这样的签名太冗长。

更新：Java 8包含了类java.util.Optional中的类，因此在java 8中不需要使用guava。方法名是虽然有点不同。

**构建器模式用于构造器，并通过引入一个单独的Builder类来实现：

**class Foo {

私人的最后一个String a;

私人决赛整数b;

Foo(String a，Integer b){

this.a = a;

this.b = b;

}

// ...

}

类FooBuilder {

private String a =“”;

私人整数b = 0;

FooBuilder setA(String a){

this.a = a;

返回这个;

}

FooBuilder setB(Integer b){

this.b = b;

返回这个;

}

Foo build(){

返回新的Foo(a，b);

}

}

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

当参数的数量太大，并且通常使用大多数默认值时，可以将方法参数作为名称/值的映射： p>void foo(Map＆lt; String，Object＆gt; parameters){

String a =“”;

整数b = 0;

if(parameters.containsKey(“a”)){

if(！(parameters.get(“a”)instanceof Integer)){

抛出新的IllegalArgumentException(“...”);

}

a =(Integer)parameters.get(“a”);

}

if(parameters.containsKey(“b”)){

// ...

}

// ...

}

foo(ImmutableMap。＆lt; String，Object＆gt;的(

“一”，“一”，

“b”，2，

“d”，“value”));

请注意，您可以结合使用这些方法来获得理想的效果。

未经作者同意，本文严禁转载，违者必究！