【问题标题】：How do I use optional parameters in Java?如何在 Java 中使用可选参数？
【发布时间】：2009-06-08 16:12:29
【问题描述】：

什么规范支持可选参数？

【问题讨论】：

标签： java optional-parameters

【解决方案1】：

在Java中有几种模拟可选参数的方法：

方法重载。

void foo(String a, Integer b) { //... }

void foo(String a) { 富（一，0）； // 这里，0 是 b 的默认值 }

foo("a", 2); foo("a");

这种方法的一个限制是，如果您有两个相同类型的可选参数并且其中任何一个都可以省略，则它不起作用。

可变参数。

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

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

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

void foo(String a, Integer b, Integer c) { b = b != 空？乙：0； c = c != 空？ c：0； //... }

foo("a", null, 2);

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

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

void foo(String a, 可选 bOpt) { 整数 b = bOpt.isPresent() ？ bOpt.get() : 0; //... }

foo("a", Optional.of(2)); foo("a", Optional.absent());

Optional 使调用者的方法契约明确，但是，人们可能会发现这样的签名过于冗长。

更新：Java 8 包含开箱即用的 java.util.Optional 类，因此在 Java 8 中出于这个特殊原因不需要使用 guava。不过方法名称有点不同。

Builder模式。builder模式用于构造函数，通过引入一个单独的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();

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

void foo(Map 参数) { 字符串 a = ""; 整数 b = 0; if (parameters.containsKey("a")) { if (!(parameters.get("a") instanceof Integer)) { throw new IllegalArgumentException("..."); } a = (Integer)parameters.get("a"); } if (parameters.containsKey("b")) { //... } //... }

foo(ImmutableMap.of( “一个”，“一个”， "b", 2, "d", "值"));

在 Java 9 中，这种方法变得更容易：
```
@SuppressWarnings("unchecked")
static <T> T getParm(Map<String, Object> map, String key, T defaultValue) {
  return (map.containsKey(key)) ? (T) map.get(key) : defaultValue;
}

void foo(Map<String, Object> parameters) {
  String a = getParm(parameters, "a", "");
  int b = getParm(parameters, "b", 0);
  // d = ...
}

foo(Map.of("a","a",  "b",2,  "d","value"));
```

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

【讨论】：

@Robino 替代链接认为 Optional 不应用作参数 here。尽管在其中一个选项中使用了Optional 作为参数，但这个答案非常好。
解决上述问题最常见的方法可能是方法重载。虽然我从来都不是那个的粉丝。如果他们为配置参数添加某种标识符，我个人更喜欢。
这应该是最好的答案 - 涵盖所有
投票构建者方法，这比地图更安全。在为可能会被重用的组件设计 API 时，将额外的精力投入到适当的 Builders 中会产生很大的不同。
我有一个类 User 有 15 个字段。其中近 10 个是可选的，它们可能为空或不为空，具体取决于最终用户的输入。与 JS 相比，创建 User 对象需要大量额外的代码。此类课程的最佳解决方案是什么？

【解决方案2】：

Java 中没有可选参数。您可以做的是重载函数，然后传递默认值。

void SomeMethod(int age, String name) {
    //
}

// Overload
void SomeMethod(int age) {
    SomeMethod(age, "John Doe");
}

【讨论】：

【解决方案3】：

Java 5.0 有可选参数。只需像这样声明您的函数：

public void doSomething(boolean... optionalFlag) {
    //default to "false"
    //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}

您现在可以拨打doSomething(); 或doSomething(true);。

【讨论】：

这其实是正确的答案。它简单而紧凑。请记住，您可以获得多个参数，因此 Java 将它们放在一个数组中。例如，要检索单个参数，您将首先检查数组的内容： 'code' boolean flag = (optionalFlag.length
不，这不是正确答案，因为这不允许单个可选参数，而是允许任意数量的可选参数。虽然这与 OP 想要的很接近，但并不相同。接受比您需要的更多的参数是错误和误解的潜在来源。
如果你只有一个可选参数，这种方法可以工作，但你需要检查数组的长度等，所以它不是超级干净：|如果你想要“一个参数”可选参数，那么你也可以只声明两个方法（一个重载doSomething() { doSomething(true); }没有要处理的数组，没有歧义
如果有多个可选参数，只有当它们都是相同的数据类型时才有效。好吧，你可以将类型设为 Object，但这真的很难看。
正如@sleske 所指出的，使用可变参数有一个可怕的缺点，即允许传递多个值。 OP 明确询问了“可选”的解决方案，这意味着一个值或零。某些人怎么能认为这是一个好的答案。

【解决方案4】：

varargs 可以做到这一点（在某种程度上）。除此之外，必须提供方法声明中的所有变量。如果您希望变量是可选的，您可以使用不需要参数的签名重载方法。

private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) {
    ...
}

public void doSomething() {
    doSomething(defaultOptionalFlagValue);
}

【讨论】：

在我看来，方法重载是一个很好的答案，而可变参数是一个非常糟糕的答案。请删除对 varargs 的评论，或者解释由于可能有多个返回值而造成的严重劣势。
添加全局变量可能会导致一些其他问题。

【解决方案5】：

你可以像这样使用方法重载来做事。

 public void load(String name){ }

 public void load(String name,int age){}

你也可以使用@Nullable注解

public void load(@Nullable String name,int age){}

只需将 null 作为第一个参数传递。

如果你传递相同类型的变量，你可以使用这个

public void load(String name...){}

【讨论】：

【解决方案6】：

你可以这样使用：

public void addError(String path, String key, Object... params) { 
}

params 变量是可选的。它被视为一个可以为空的 Objects 数组。

奇怪的是，我在文档中找不到任何关于此的内容，但它有效！

这是 Java 1.5 及更高版本中的“新”（Java 1.4 或更早版本不支持）。

我看到用户 bhoot 在下面也提到了这一点。

【讨论】：

【解决方案7】：

在JDK>1.5中可以这样使用；

public class NewClass1 {

    public static void main(String[] args) {

        try {
            someMethod(18); // Age : 18
            someMethod(18, "John Doe"); // Age & Name : 18 & John Doe
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void someMethod(int age, String... names) {

        if (names.length > 0) {
            if (names[0] != null) {
                System.out.println("Age & Name : " + age + " & " + names[0]);
            }
        } else {
            System.out.println("Age : " + age);
        }
    }
}

【讨论】：

这是正确的，if () {} else {} 不利于代码维护。在我看来，方法重载是正确的答案。

【解决方案8】：

重载没问题，但是如果有很多变量需要默认值，你最终会得到：

public void methodA(A arg1) {  }    
public void methodA(B arg2) {  }
public void methodA(C arg3) {  }
public void methodA(A arg1, B arg2) {  }
public void methodA(A arg1, C arg3) {  }
public void methodA(B arg2, C arg3) {  }
public void methodA(A arg1, B arg2, C arg3) {  }

所以我建议使用Java提供的Variable Argument。

【讨论】：

使用可变参数被认为是不好的做法。如果系统需要这样的（上面提到的）方法，那么你应该考虑一个新的设计，因为类设计看起来很糟糕。
更糟糕的做法是为 Java 缺陷找借口，并指责其他人注意到这些不便并设计解决方法的不良做法。
请将所有相关信息添加到您的答案中，而不是链接到外部资源 - 给定的链接已失效
这样的代码是一种代码味道，无论如何都应该重构——使用引入参数对象或转换为功能接口并使用构建器模式。

【解决方案9】：

这是一个老问题，甚至可能在引入实际 Optional 类型之前，但现在你可以考虑几件事： - 使用方法重载 - 使用具有避免传递 NULL 的优点的可选类型可选类型是在 Java 8 中引入的，然后通常从第三方库（例如 Google 的 Guava）中使用。使用可选作为参数/参数可以被认为是过度使用，因为主要目的是将其用作返回时间。

参考：https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html

【讨论】：

【解决方案10】：

短版：

使用三个点：

public void foo(Object... x) {
    String first    =  x.length > 0 ? (String)x[0]  : "Hello";
    int duration    =  x.length > 1 ? Integer.parseInt((String) x[1])     : 888;
}   
foo("Hii", ); 
foo("Hii", 146);

（基于@VitaliiFedorenko 的回答）

【讨论】：

【解决方案11】：

如果是 API 端点，一种优雅的方式是使用“Spring”注解：

@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam(required = false, defaultValue = "hello") String id) { 
    return innerFunc(id);
}

请注意，在这种情况下，innerFunc 将需要变量，并且由于它不是 api 端点，因此不能使用此 Spring 注释使其成为可选。参考：https://www.baeldung.com/spring-request-param

【讨论】：

【解决方案12】：

已经提到了 VarArgs 和重载。另一种选择是 Bloch Builder 模式，它看起来像这样：

 MyObject my = new MyObjectBuilder().setParam1(value)
                                 .setParam3(otherValue)
                                 .setParam6(thirdValue)
                                 .build();

虽然该模式最适合您在构造函数中需要可选参数的情况。

【讨论】：

我想为那个添加参数依赖项。假设我只在设置 param1 时才设置 param3。例如。只有当我设置进度可见时，我才想设置进度消息。 isProgressVisible().setProgressMessage("loading") 。我怎样才能做到这一点？
@HarshalBhatt 我知道这已经晚了 6 年，但对于其他人来说。您可以在运行时通过检查构建方法来强制执行它。您还可以创建一个构建器类，该类具有从您的 setProgressVisible 方法返回的更多有限接口。但很大程度上取决于您希望构建语义的确切方式。

【解决方案13】：

您可以使用类似于构建器的类来包含这样的可选值。

public class Options {
    private String someString = "default value";
    private int someInt= 0;
    public Options setSomeString(String someString) {
        this.someString = someString;
        return this;
    }
    public Options setSomeInt(int someInt) {
        this.someInt = someInt;
        return this;
    }
}

public static void foo(Consumer<Options> consumer) {
    Options options = new Options();
    consumer.accept(options);
    System.out.println("someString = " + options.someString + ", someInt = " + options.someInt);
}

使用喜欢

foo(o -> o.setSomeString("something").setSomeInt(5));

输出是

someString = something, someInt = 5

要跳过所有可选值，您必须像 foo(o -> {}); 一样调用它，或者如果您愿意，可以创建第二个不采用可选参数的 foo() 方法。

使用这种方法，您可以以任何顺序指定可选值，而不会产生任何歧义。与可变参数不同，您还可以拥有不同类的参数。如果您可以使用注释和代码生成来创建 Options 类，这种方法会更好。

【讨论】：

【解决方案14】：

我们可以通过方法重载或使用DataType来制作可选参数...

|*|方法重载：

RetDataType NameFnc(int NamePsgVar)
{
    // |* Code Todo *|
    return RetVar;
}

RetDataType NameFnc(String NamePsgVar)
{
    // |* Code Todo *|
    return RetVar;
}

RetDataType NameFnc(int NamePsgVar1, String NamePsgVar2)
{
    // |* Code Todo *|
    return RetVar;
}

最简单的方法是

|*| DataType...可以是可选参数

RetDataType NameFnc(int NamePsgVar, String... stringOpnPsgVar)
{
    if(stringOpnPsgVar.length == 0)  stringOpnPsgVar = DefaultValue; 

    // |* Code Todo *|
    return RetVar;
}

【讨论】：

RetDtaTyp... 认真的吗？ RetDataType 是不是太难输入了？
您能对该代码添加更多解释吗？所有这些奇怪的变量有什么作用？

【解决方案15】：

Java 中不能使用默认参数。在 C#、C++ 和 Python 中，我们可以在哪里使用它们..

在 Java 中，我们必须使用 2 种方法（函数）而不是一种带有默认参数的方法。

例子：

Stash(int size); 

Stash(int size, int initQuantity);

http://parvindersingh.webs.com/apps/forums/topics/show/8856498-java-how-to-set-default-parameters-values-like-c-

【讨论】：

较新版本的 C# 允许使用默认参数。
java 对于任何参数也有“...”选项。

【解决方案16】：

Java 现在在 1.8 中支持可选项，我一直坚持在 android 上编程，所以我一直使用空值，直到我可以重构代码以使用可选类型。

Object canBeNull() {
    if (blah) {
        return new Object();
    } else {
        return null;
    }
}

Object optionalObject = canBeNull();
if (optionalObject != null) {
    // new object returned
} else {
    // no new object returned
}

【讨论】：

你能提供例子吗？

【解决方案17】：

如果您计划使用具有多个参数的界面，可以使用以下结构模式并实施或覆盖 apply - 一种基于您的要求的方法。

public abstract class Invoker<T> {
    public T apply() {
        return apply(null);
    }
    public abstract T apply(Object... params);
}

【讨论】：