没有，但最简单的实现方法是：

public myParameterizedFunction(String param1, int param2, Boolean param3) {

    param3 = param3 == null ? false : param3;
}

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

或代替三元运算符，可以使用以下条件：

public myParameterizedFunction(String param1, int param2, Boolean param3) {

    if (param3 == null) {
        param3 = false;
    }
}

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

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

方法重载。void foo（字符串a，整数b）{//...}void foo（字符串a）{foo（a，0）；//这里，0是b的默认值}foo（“a”，2）；foo（“a”）；这种方法的一个限制是，如果您有两个相同类型的可选参数，并且可以省略其中的任何一个，那么它就不起作用。变量。a） 所有可选参数的类型相同：void foo（字符串a，整数…b）{整数b1=b.length>0？b[0]：0；整数b2=b.length>1？b[1]:0；//...}foo（“a”）；foo（“a”，1，2）；b） 可选参数的类型可能不同：void foo（字符串a，对象…b）{整数b1=0；字符串b2=“”；如果（b.length>0）{if（！（b[0]instanceof Integer））｛抛出新的IllegalArgumentException（“…”）；}b1=（整数）b[0]；}如果（b.长度>1）{if（！（b[1]instanceof String））｛抛出新的IllegalArgumentException（“…”）；}b2=（字符串）b[1]；//...}//...}foo（“a”）；foo（“a”，1）；foo（“a”，1，“b2”）；这种方法的主要缺点是，如果可选参数的类型不同，则会丢失静态类型检查。此外，如果每个参数具有不同的含义，则需要一些方法来区分它们。Null。为了解决前面方法的局限性，可以允许空值，然后分析方法体中的每个参数：void foo（字符串a、整数b、整数c）{b=b！=无效的b:0；c=c！=无效的c:0；//...}foo（“a”，null，2）；现在必须提供所有参数值，但默认值可能为空。可选类。这种方法类似于null，但对具有默认值的参数使用Java 8 Optional类：void foo（字符串a，可选＜整数＞bOpt）{整数b=bOpt.isPresent（）？bOpt.get（）：0；//...}foo（“a”，可选，第（2）项）；foo（“a”，可选。＜Integer＞absent（））；可选使方法契约对调用方显式，但是，可能会发现这种签名过于冗长。生成器模式。生成器模式用于构造函数，通过引入单独的生成器类来实现：Foo类{private final字符串a；私有最终整数b；Foo（字符串a，整数b）{这个.a=a；此.b=b；}//...}类FooBuilder{private字符串a=“”；私有整数b=0；FooBuilder setA（字符串a）{这个.a=a；返回此；}FooBuilder集合b（整数b）{此.b=b；返回此；}Foo build（）{返回新的Foo（a，b）；}}Foo Foo=新建FooBuilder（）.setA（“a”）.build（）；地图。当参数的数量太大并且大多数参数通常使用默认值时，可以将方法参数作为其名称/值的映射传递：void foo（Map＜String，Object＞参数）{字符串a=“”；整数b=0；if（parameters.containsKey（“a”））｛if（！（parameters.get（“a”）instanceof Integer））｛抛出新的IllegalArgumentException（“…”）；}a=（字符串）参数.get（“a”）；}否则如果（parameters.containsKey（“b”））｛//... }//...}foo（ImmutableMap.＜String，Object＞of(“a”、“a”，“b”，2，“d”、“值”）；

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

遗憾的是，没有。

我现在花了很多时间来研究如何将它与返回值的方法一起使用，到目前为止我还没有看到任何示例，我认为在这里添加这个可能很有用：

int foo(int a) {
    // do something with a
    return a;
}

int foo() {
    return foo(0); // here, 0 is a default value for a
}

您可以使用Java方法调用生成器自动生成具有默认值的生成器。

只需将@GenerateMethodInvocationBuilder添加到类或接口，并将@Default添加到需要默认值的方法中的参数。编译时将使用您在注释中指定的默认值生成生成器。

@GenerateMethodInvocationBuilder
public class CarService {
 public CarService() {
 }

 public String getCarsByFilter(//
   @Default("Color.BLUE") Color color, //
   @Default("new ProductionYear(2001)") ProductionYear productionYear,//
   @Default("Tomas") String owner//
 ) {
  return "Filtering... " + color + productionYear + owner;
 }
}

然后可以调用这些方法。

CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .invoke(instance);

或者将任何默认值设置为其他值。

CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .withColor(Color.YELLOW)//
  .invoke(instance);

不幸的是，是的。

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

可以用Java 1.5写成：

void MyParameterizedFunction(String param1, int param2, Boolean... params) {
    assert params.length <= 1;
    bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}

但是否应该取决于您对编译器生成

new Boolean[]{}

每次通话。

对于多个默认参数：

void MyParameterizedFunction(String param1, int param2, bool param3=false, int param4=42) {}

可以用Java 1.5写成：

void MyParameterizedFunction(String param1, int param2, Object... p) {
    int l = p.length;
    assert l <= 2;
    assert l < 1 || Boolean.class.isInstance(p[0]);
    assert l < 2 || Integer.class.isInstance(p[1]);
    bool param3 = l > 0 && p[0] != null ? ((Boolean)p[0]).booleanValue() : false;
    int param4 = l > 1 && p[1] != null ? ((Integer)p[1]).intValue() : 42;
}

这与C++语法相匹配，后者只允许在参数列表的末尾使用默认参数。

除了语法之外，还有一个不同之处，即它对传递的默认参数进行了运行时类型检查，而C++在编译过程中对它们进行了类型检查。