Java是否支持默认参数值？

Question

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

Answer 1

不,您找到的结构是Java如何处理它(即,使用重载而不是默认参数).

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

Answer 2

不,但您可以使用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();

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

Answer 3

有几种方法可以在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)可选参数的类型可能不同:

   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. 空值.要解决先前方法的局限性,您可以允许空值,然后分析方法体中的每个参数:

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

   现在必须提供所有参数值,但默认值可以为null.

4. 可选课程.此方法类似于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());
   

   可选为调用者显示方法契约,但是,人们可能会发现这样的签名过于冗长.

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

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

Answer 4

可悲的是没有.

Answer 5

不幸的是,是的.

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++类型在编译期间检查它们.

Answer 6

不,但你可以很容易地模仿它们.C++中的内容是:

public: void myFunction(int a, int b=5, string c="test") { ... }

在Java中,它将是一个重载函数:

public void myFunction(int a, int b, string c) { ... }

public void myFunction(int a, int b) {
    myFunction(a, b, "test");
}

public void myFunction(int a) {
    myFunction(a, 5);
}

之前提到过,默认参数导致函数重载的模糊情况.这根本不是真的,我们可以在C++的情况下看到:是的,也许它可以创建模糊的情况,但这些问题可以很容易地处理.它本身并不是用Java开发的,可能是因为创作者想要一种更简单的语言,因为C++是 - 如果他们有正确的话,则是另一个问题.但是我们大多数人并不认为他使用Java是因为它简单.

Answer 7

您可以在Scala中执行此操作,Scala在JVM上运行并与Java程序兼容. http://www.scala-lang.org/

即

class Foo(var prime: Boolean = false, val rib: String)  {}

Answer 8

而不是使用：

void parameterizedMethod(String param1, int param2) {
    this(param1, param2, false);
}

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

您可以通过一个方法来利用 java 的 Optional 功能：

void parameterizedMethod(String param1, int param2, @Nullable Boolean param3) {
    param3 = Optional.ofNullable(param3).orElse(false);
    //use all three parameters here
}

主要区别在于您必须使用包装类而不是原始 Java 类型来允许null输入。Boolean而不是boolean，Integer而不是int等等。

Answer 9

不,但最简单的实现方法是:

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

Answer 10

我可能会在这里说明显而易见但为什么不自己简单地实现"默认"参数？

public class Foo() {
        public void func(String s){
                func(s, true);
        }
        public void func(String s, boolean b){
                //your code here
        }
}

默认情况下,您将使用以太网

func("我的字符串");

如果你不想使用默认值,你会使用

func("my string",false);

Answer 11

java 不支持它，而其他语言则不支持它。科特林。

Answer 12

正如提到Scala一样，Kotlin也值得一提。在Kotlin函数中，参数也可以具有默认值，甚至可以引用其他参数：

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    ...
}

与Scala一样，Kotlin可以在JVM上运行，并且可以轻松地集成到现有的Java项目中。

Answer 13

没有.

您可以通过传递具有智能默认值的Object来实现相同的行为.但这又取决于你的情况.

Answer 14

不.通常,Java没有太多(任何)语法糖,因为他们试图制作一种简单的语言.