问题

我遇到了一些具有以下结构的Java代码：

public MyParameterizedFunction(String param1, int param2)
{
    this(param1, param2, false);
}

public MyParameterizedFunction(String param1, int param2, boolean param3)
{
    //use all three parameters here
}

我知道在C我可以分配一个参数的默认值。例如：

void MyParameterizedFunction(String param1, int param2, bool param3=false);

Java是否支持这种语法？有没有任何理由为什么这两个步骤的语法是可取的？

#1 热门回答(741 赞)

不，您发现的结构是Java如何处理它(即，使用重载而不是默认参数)。

对于构造函数，如果重载变得复杂，则使用See Effective Java: Programming Language Guide'sItem 1提示(考虑静态工厂方法而不是构造函数)。对于其他方法，重命名某些情况或使用参数对象可以提供帮助。这是当你有足够的复杂性，差异化是困难的。一个确定的情况是你必须使用参数顺序进行区分，而不仅仅是数字和类型。

#2 热门回答(536 赞)

不，但您可以使用Builder Pattern，如this Stack Overflow answer中所述。

正如链接答案中所述，Builder模式允许您编写类似的代码

Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
                 .name("Spicoli")
                 .age(16)
                 .motto("Aloha, Mr Hand")
                 .buildStudent();

其中一些字段可以具有默认值或者是可选的。

#3 热门回答(344 赞)

有几种方法可以模拟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];
    }
    如果(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，Optional <Integer> bOpt){
整数b = bOpt.isPresent()？ bOpt.get()：0;
// ...
}

foo(“a”，Optional.of(2));
foo(“a”，可选。<Integer> absent());
可选方法为调用方明确了方法合同，但是，可能会发现这样的签名过于冗长。

建造者模式。构建器模式用于构造函数，并通过引入一个单独的Builder类来实现：class Foo {
private final String a;
private final Integer b;

     Foo(字符串a，整数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();

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

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

请注意，您可以将这些方法结合起来，以达到理想的效果。

原文链接

Java是否支持默认参数值？

问题

#1 热门回答(741 赞)

#2 热门回答(536 赞)

#3 热门回答(344 赞)

相关问题