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

网友回答：

否，但您可以使用构建器模式，如本堆栈溢出答案中所述。

如链接答案中所述，生成器模式允许您编写类似

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

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

网友回答：

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

对于构造函数，请参阅有效的 Java：编程语言指南的第 1 项提示（考虑静态工厂方法而不是构造函数）

如果重载变得复杂。对于其他方法，重命名某些情况或使用参数对象会有所帮助。

这是当您具有足够的复杂性以至于难以区分时。一个明确的情况是，您必须使用参数的顺序进行区分，而不仅仅是数字和类型。

网友回答：

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

1. 方法重载。

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

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

2. 瓦拉格斯。
   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) Types of optional parameters may be different:

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

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

3. 空值。为了解决以前方法的局限性，您可以允许 null 值，然后分析方法主体中的每个参数：

   void foo(String a, Integer b, Integer c) {
       b = b != null ? b : 0;
       c = c != null ? c : 0;
       //...
   }
   
   foo("a", null, 2);
   

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

4. 可选类。此方法类似于 nulls，但对具有缺省值的参数使用 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());
   

   Optional 使方法协定对调用方显式，但是，可能会发现这样的签名过于冗长。

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

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

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

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