Java 是否支持默认参数值？

我遇到了一些具有以下结构的 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 是否支持这种语法？有没有理由说这两步语法更可取？

答案

不，您找到的结构是 Java 如何处理它（即，使用重载而不是默认参数）。

对于构造函数，如果重载变得复杂， 请参阅 Effective Java：Programming Language Guide 的第 1 项提示（考虑静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象可能会有所帮助。这是因为当你有足够的复杂性时难以区分。一个明确的情况是你必须使用参数的顺序区分，而不仅仅是数字和类型。

不，但您可以使用Builder Pattern ，如此 Stack Overflow 答案中所述。

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

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

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

有几种方法可以在 Java 中模拟默认参数：

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

void foo(String a) {
    foo(a, 0); // here, 0 is a default value for b
}

foo("a", 2);
foo("a");
```
这种方法的一个限制是，如果您有两个相同类型的可选参数并且可以省略任何参数，则它不起作用。

可变参数。

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

这种方法的主要缺点是，如果可选参数属于不同类型，则会丢失静态类型检查。此外，如果每个参数具有不同的含义，您需要一些方法来区分它们。

空值。要解决先前方法的局限性，您可以允许空值，然后分析方法体中的每个参数：
```
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) {
    Integer b = bOpt.isPresent() ? bOpt.get() : 0;
    //...
}

foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());
```
可选为调用者显示方法契约，但是，人们可能会发现这样的签名过于冗长。

生成器模式。构建器模式用于构造函数，并通过引入单独的 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();

地图。当参数的数量太大时，对于大多数参数，通常使用默认值，您可以将方法参数作为其名称 / 值的映射传递：

void foo(Map<String, Object> parameters) {
    String a = ""; 
    Integer b = 0;
    if (parameters.containsKey("a")) { 
        if (!(parameters.get("a") instanceof Integer)) { 
            throw new IllegalArgumentException("...");
        }
        a = (String)parameters.get("a");
    } else if (parameters.containsKey("b")) { 
        //... 
    }
    //...
}

foo(ImmutableMap.<String, Object>of(
    "a", "a",
    "b", 2, 
    "d", "value"));

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