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：编程语言指南的第 1 项提示（考虑静态工厂方法而不是构造函数）。 对于其他方法，重命名某些情况或使用参数对象会有所帮助。 这是当你有足够的复杂性时，区分是困难的。 一个明确的情况是您必须使用参数的顺序进行区分，而不仅仅是数字和类型。

Answer 2

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

如链接的答案中所述，构建器模式可让您编写如下代码

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

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

4. 选修课。 这种方法类似于空值，但对具有默认值的参数使用 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"));

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

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

IE

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

Answer 8

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

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

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

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

或者代替三元运算符，您可以使用if ：

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

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

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

Answer 9

而不是使用：

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 10

我可能在这里说明了显而易见的问题，但为什么不自己实现“默认”参数呢？

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

默认情况下，您可以使用

func("my string");

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

func("my string", false);

Answer 11

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

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

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

Answer 12

不。

您可以通过传递具有智能默认值的对象来实现相同的行为。 但这同样取决于您手头的情况。

Answer 13

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

Answer 14

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

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 15

试试这个解决方案：

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

    return score;
}

Answer 16

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

与其他语言一样，java 不支持它，例如。 科特林。

Answer 18

在 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 19

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

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

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

Answer 20

像 for 方法这样的构造函数

static void popuping() {
    popuping("message", "title");
}
static void popuping(String message) {
    popuping(message, "title");
}
static void popuping(String message, String title){
    JOptionPane.showMessageDialog(null, message,
            title, JOptionPane.INFORMATION_MESSAGE);
}

Answer 21

有六个或更好的问题，例如这样，最终，您会到达静态工厂模式……请参阅加密 API。 排序很难解释，但可以这样想：如果你有一个构造函数，无论是默认的还是其他的，在大括号之外传播状态的唯一方法要么是有一个布尔值 isValid； （连同 null 作为默认值 v 构造函数失败）或抛出一个异常，当从现场用户那里取回它时，它永远不会提供信息。

代码正确该死，我编写了千行构造函数并做我需要的。 我发现在对象构造中使用 isValid - 换句话说，两行构造函数 - 但出于某种原因，我正在迁移到静态工厂模式。 如果您在方法调用中，我似乎可以做很多事情，仍然存在 sync() 问题，但可以更好地“替换”默认值（更安全）

我认为我们在这里需要做的是解决 null 作为默认值与 String one=new String(""); 相比的问题。 作为成员变量，然后在分配传递给构造函数的字符串之前检查 null。

用 Java 完成的原始、平流层计算机科学的数量非常惊人。

C++ 等有供应商库，是的。 由于它是一个庞大的工具箱，Java 可以在大型服务器上运行它们。 研究静态初始化块，和我们在一起。

Answer 22

我就是这样做的……这可能不像对定义的参数使用“可选参数”那样方便，但它可以完成工作：

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 的功能。

我实际上认为这比 Java 为我们的参数提供一个“可选参数”要简洁一些，因为我们需要为默认值等编码。在这个例子中，我不需要担心任何这些。 是的，我已经在我的类中添加了另一种方法，但从我的拙见，从长远来看，它更容易阅读。

Answer 23

不，但是我们有函数重载形式的替代方案。

未传递参数时调用

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 24

一种想法是使用String... args

public class Sample {
   void demoMethod(String... args) {
      for (String arg : args) {
         System.out.println(arg);
      }
   }
   public static void main(String args[] ) {
      new Sample().demoMethod("ram", "rahim", "robert");
      new Sample().demoMethod("krishna", "kasyap");
      new Sample().demoMethod();
   }
}

输出

ram
rahim
robert
krishna
kasyap

来自https://www.tutorialspoint.com/Does-Java-support-default-parameter-values-for-a-method

Answer 25

如果你真的想要，你可以使用null手动检查它：

public MyParameterizedFunction(String param1, int param2, boolean param3)
{
    if(param3 == null) {
        param3 = false;
    }
}

但是我强烈建议使用其他东西，比如重载或静态工厂。 也许您可以摆脱这种情况，但它可能会导致意外行为。 例如，您的代码中可能有错误，因此您的布尔值永远不会获得值。 在这种情况下，您不会得到NullPointerException 。 相反，它看起来像是设置为 false，这可能会导致调试非常混乱。

Answer 26

您可以使用以下-

public void mop(Integer x) {
  // Define default values
        x = x == null ? 200 : x;
}

Answer 27

直接的答案是否定的。

这些答案已经很老了，主要讨论了即使 java 没有默认方法参数的直接方式，我们也可以拥有的替代方案。

我们可以使用 java 中的函数式编程轻松处理这种情况。

我们可以利用 java 函数式编程的方法柯里化，我认为它最适合用于需要默认参数的场景。

在以下情况下，我们可能需要一个默认参数...示例：创建一个适用于两个不同对象并返回计算结果的方法

int mutiply(int a,int b){

      return a*b;

  }

如果我们想要一个乘以 2 的方法，我们将不得不重写下面的方法

int mutiply(int a){

      mutiply(a, 2); // as can not write mutiply(int a,b=2)

  }

上面，2 是 b 的默认值，但它将被修复。 如果我们想乘以 3 怎么办，现在我们不能再重载它了，拥有多个像这样的方法确实感觉很奇怪。

这是我们可以使用方法柯里化技术的时候。

method Currying 是将多参数函数转换为多个函数的方法，每个函数接受一个参数。

创建 Curried 方法的步骤

1. 编写一个接受单个参数并返回另一个函数的函数，如下所示。

    Function<Integer,Function<Integer,Integer>> mutiply = a->{ return b -> a*b; };

2. 让我们简化并理解上述方法。

Above 方法只接受一个整数 Argument 并返回另一个函数，其中一个参数 a 作为默认值，b 作为变量。 如果您感到困惑并开始思考该方法如何使用调用函数中的变量并且不了解闭包......

“闭包是在其词法上下文中引用自由变量的函数。” 所以在这里，在这种情况下，闭包是对变量 multiply 操作时返回的函数，它有一个自由变量 a，它具有调用函数的词法上下文。

3. 返回 multiply 方法或修复其中一个参数的默认值。

    //multiply is defined in the first step mutiplyByTwo = mutiply.apply(2) mutiplyByThree = mutiply.apply(3); mutiplyByFour = mutiply.apply(4);;

   等等 …

4. 将第二个变量传递给返回的函数以获得结果。

    mutiplyByTwo.apply(2);//results mutiplyByTwo.apply(3);//results 6 mutiplyByThree.apply(2);//results 6 mutiplyByThree.apply(3);//results 9 mutiplyByFour.apply(2);//results 8 mutiplyByFour.apply(3);//results 124

你可以在这里找到我的原始帖子...... https://www.linkedin.com/pulse/can-we-have-default-method-parameter-java-rajat-singh/?trackingId=yW84I1fzT6WGStrNPAWn4w%3D%3D

Answer 28

是的 = 使用 Kotlin！ )))

这是个笑话；