Java 可选参数
Posted
技术标签:
【中文标题】Java 可选参数【英文标题】：How do I use optional parameters in Java? 【发布时间】：2010-11-01 05:30:27 【问题描述】：如何在 Java 中使用可选参数？什么规范支持可选参数？
【问题讨论】：
【参考方案1】：varargs 可以做到这一点（在某种程度上）。除此之外，必须提供方法声明中的所有变量。如果您希望变量是可选的，您可以使用不需要参数的签名重载方法。
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag)
...
public void doSomething()
doSomething(defaultOptionalFlagValue);
【讨论】：
在我看来，方法重载是一个很好的答案，而可变参数是一个非常糟糕的答案。请删除对 varargs 的评论，或者解释由于可能有多个返回值而造成的严重劣势。 添加全局变量可能会导致一些其他问题。【参考方案2】：Java 中没有可选参数。您可以做的是重载函数，然后传递默认值。
void SomeMethod(int age, String name)
//
// Overload
void SomeMethod(int age)
SomeMethod(age, "John Doe");
【讨论】：
【参考方案3】：已经提到了 VarArgs 和重载。另一种选择是 Bloch Builder 模式，它看起来像这样：
MyObject my = new MyObjectBuilder().setParam1(value)
.setParam3(otherValue)
.setParam6(thirdValue)
.build();
虽然这种模式最适合您在构造函数中需要可选参数的情况。
【讨论】：
我想为那个添加参数依赖项。假设我只在设置 param1 时才设置 param3。例如。只有当我设置进度可见时，我才想设置进度消息。 isProgressVisible().setProgressMessage("loading") 。我怎样才能做到这一点？【参考方案4】：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 明确询问了“可选”的解决方案，这意味着一个值或零。某些人怎么能认为这是一个好的答案。【参考方案5】：
你可以这样使用：
public void addError(String path, String key, Object... params)
params 变量是可选的。它被视为一个可以为空的 Objects 数组。
奇怪的是，我在文档中找不到任何关于此的内容，但它有效！
这是 Java 1.5 及更高版本中的“新”（Java 1.4 或更早版本不支持）。
我看到用户 bhoot 在下面也提到了这一点。
【讨论】：
【参考方案6】：在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 不利于代码维护。在我看来，方法重载是正确的答案。【参考方案7】：
在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
foo(ImmutableMap.
在 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"));
请注意，您可以结合使用这些方法中的任何一种来获得理想的结果。
【讨论】：
@Vitalii Fedorenko 嗯，我认为您在 #6 中犯了一个轻微的复制粘贴错误：尽管您的a 变量是字符串，但您正在对整数进行类型检查（强制转换是正确的） .
@Robino 替代链接认为 Optional 不应用作参数 here。尽管在其中一个选项中使用了Optional 作为参数，但这个答案非常好。
解决上述问题最常见的方法可能是方法重载。虽然我从来都不是那个的粉丝。如果他们为配置参数添加某种标识符，我个人更喜欢。
这应该是最好的答案 - 涵盖所有
投票构建者方法，这比 Maps 更安全。在为可能会被重用的组件设计 API 时，将额外的精力投入到适当的 Builder 中会产生很大的不同。【参考方案8】：
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 对于任何参数也有“...”选项。【参考方案9】：重载没问题，但是如果有很多变量需要默认值，你最终会得到：
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 缺陷找借口，并指责其他人注意到这些不便并设计解决方法的不良做法。 请将所有相关信息添加到您的答案中，而不是链接到外部资源 - 给定的链接已失效 这样的代码是一种代码味道，无论如何都应该重构——使用引入参数对象或转换为功能接口并使用构建器模式。【参考方案10】：你可以像这样使用方法重载来做事。
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...)
【讨论】：
【参考方案11】：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
【讨论】：
你能提供例子吗？【参考方案12】：短版：
使用三个点：
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 的回答）
【讨论】：
【参考方案13】：我们可以通过方法重载或使用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 是不是太难输入了？
您能对该代码添加更多解释吗？所有这些奇怪的变量有什么作用？【参考方案14】：
您可以使用类似于构建器的类来包含这样的可选值。
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 类，这种方法会更好。
【讨论】：
【参考方案15】：这是一个老问题，甚至可能在引入实际 Optional 类型之前，但现在你可以考虑几件事： - 使用方法重载 - 使用具有避免传递 NULL 的优点的可选类型 可选类型是在 Java 8 中引入的，然后通常从第三方库（例如 Google 的 Guava）中使用。使用可选作为参数/参数可以被认为是过度使用，因为主要目的是将其用作返回时间。
参考：https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html
【讨论】：
【参考方案16】：如果您计划使用具有多个参数的界面， 可以使用以下结构模式并实施或覆盖 apply - 一种基于您的要求的方法。
public abstract class Invoker<T>
public T apply()
return apply(null);
public abstract T apply(Object... params);
【讨论】：
【参考方案17】：如果是 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
【讨论】：
以上是关于Java 可选参数的主要内容，如果未能解决你的问题，请参考以下文章