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支持这种语法吗？ 有没有任何理由为什么这两个步骤的语法是可取的？

Answer 1

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

对于构造函数，如果过载变得复杂， 请参阅“有效的Java：编程语言指南”的第1项技巧（考虑静态工厂方法而不是构造函数）。 对于其他方法，重命名某些情况或使用参数对象可以提供帮助。 这是当你有足够的复杂性，差异化是困难的。 一个确定的情况是你必须使用参数的顺序进行区分，而不仅仅是数字和types。

Answer 2

不，但是你可以使用Builder模式 ，就像这个Stack Overflow答案中所描述的那样。

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

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

   这种方法的局限之一是，如果你有两个相同types的可选参数，它们不起作用，任何参数都可以省略。

2. 可变参数。

   a）所有可选参数都是相同的types：

    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可能不同：

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

   这种方法的主要缺点是，如果可选参数是不同的types，你会失去静态types检查。 而且，如果每个参数有不同的含义，你需要一些方法来区分它们。

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

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

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

4. 可选课程 这种方法类似于空值，但对于具有默认值的参数使用Java 8 Optional类：

    void foo(String a, Optional bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.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 parameters) { String a = ""; Integer b = 0; if (parameters.containsKey("a")) { if (!(parameters.get("a") instanceof Integer)) { throw new IllegalArgumentException("..."); } a = (String)parameters.get("a"); } if (parameters.containsKey("b")) { //... } //... } foo(ImmutableMap.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 ++语法相匹配，只允许参数列表末尾的默认参数。

除了语法之外，在运行时间types检查中传递可违约的参数是有区别的，C ++types在编译期间检查它们。

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中执行此操作，该操作在JVM上运行，并且与Java程序兼容。 http://www.scala-lang.org/

即

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

Answer 8

我可能会在这里指出明显的，但为什么不自己实现“默认”参数呢？

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

默认情况下你会使用ether

func（“我的字符串”）;

如果你不想使用默认值，你可以使用

func（“我的字符串”，假）;

Answer 9

不。一般来说，Java没有太多（任何）语法糖，因为他们试图做一个简单的语言。

Answer 10

没有。

您可以通过传递一个具有智能默认值的对象来实现相同的行为。 但是这又取决于你的案子在哪里。

Answer 11

它不被支持，但有几个选项，如使用一些语法糖使用参数对象模式：

 public class Foo() { private static class ParameterObject { int param1 = 1; String param2 = ""; } public static void main(String[] args) { new Foo().myMethod(new ParameterObject() {{ param1 = 10; param2 = "bar";}}); } private void myMethod(ParameterObject po) { } } 

在这个例子中，我们使用默认值构造ParameterObject ，并在类实例初始化部分{ param1 = 10; param2 = "bar";} { param1 = 10; param2 = "bar";}

Answer 12

试试这个解决方案

 public int getScore(int score, Integer... bonus) { if(bonus.length > 0) { return score + bonus[0]; } return score; } 

Answer 13

不 ，但实现这个最简单的方法是：

 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 14

有这么多的问题或者更好的问题，最终你会到达静态的工厂模式…看到这个密码API。 排序很难解释，但这样想：如果你有一个构造函数，默认或其他的方式，超越大括号传播状态的唯一方法是有一个布尔isValid; （以null作为默认值v失败的构造函数），或者抛出一个exception，当从现场用户获取它时从不会提供信息。

代码正确的被定罪，我写千行的构造函数，并做我所需要的。 我发现在对象构造中使用isValid – 换句话说，两个线构造函数 – 但由于某种原因，我正在迁移到静态工厂模式。 我似乎你可以做很多，如果你在一个方法调用，仍然有同步（）的问题，但默认可以被“替代”更好（更安全）

我认为我们在这里需要做的是解决null作为缺省值的问题，相对于某些东西来说String one = new String（“”）; 作为成员variables，然后在分配传递给构造函数的字符串之前检查null。

在Java中完成的原始的平流层计算机科学数量非常显着。

C ++等有供应商库，是的。 由于它的大量工具箱，Java可以在大型服务器上超越它们。 学习静态初始化块，留在我们身边。

Answer 15

在Java 8中使用类似的方法https://stackoverflow.com/a/13864910/2323964是使用默认的getter接口。 这将是更多的空白详细，但是可以嘲笑，这是伟大的，当你有一堆实际上你真的想引起注意的参数。

 public class Foo() { public interface Parameters { String getRequired(); default int getOptionalInt(){ return 23; } default String getOptionalString(){ return "Skidoo"; } } public Foo(Parameters parameters){ //... } public static void baz() { final Foo foo = new Foo(new Person() { @Override public String getRequired(){ return "blahblahblah"; } @Override public int getOptionalInt(){ return 43; } }); } } 

Answer 16

不，但是我们有替代function重载的forms。

当没有parameter passing时调用

 void operation(){ int a = 0; int b = 0; } 

当“a”参数通过时调用

 void operation(int a){ int b = 0; //code } 

当参数b通过时调用

 void operation(int a , int b){ //code } 

Answer 17

这就是我所做的…它不像对你定义的参数有一个“可选参数”那么方便，但它完成了工作：

 public void postUserMessage(String s,boolean wipeClean) { if(wipeClean) { userInformation.setText(s + "\n"); } else { postUserMessage(s); } } public void postUserMessage(String s) { userInformation.appendText(s + "\n"); } 

注意我可以用一个字符串调用同一个方法名，也可以用一个字符串和一个布尔值来调用它。 在这种情况下，将wipeClean设置为true会将我的TextArea中的所有文本替换为提供的字符串。 将wipeClean设置为false或将它们全部放在一起只需将提供的文本附加到TextArea。

另外请注意，我不是在这两个方法中重复代码，我只是添加了能够通过创建一个新的方法重置TextArea的function，只有添加了布尔值。

我实际上认为这比Java为我们的参数提供了一个“可选参数”要简洁一些，因为我们需要编码默认值等等。在这个例子中，我不需要担心这些。 是的，我已经给class上增加了另外一种方法，但从长远来看，我认为更容易理解。

Answer 18

您可以使用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); 

Answer 19

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

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

像Scala一样，Kotlin运行在JVM上，可以很容易地集成到现有的Java项目中。