如何在Java中使用可选参数？什么规范支持可选参数？
答案 0 :(得分：1529)
有几种方法可以在Java中模拟可选参数：
方法重载。
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");
这种方法的一个限制是，如果您有两个相同类型的可选参数，并且可以省略任何参数，则它不起作用。
<强>可变参数。
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。要解决以前方法的局限性，您可以允许空值，然后分析方法体中的每个参数：
void foo(String a, Integer b, Integer c) {
b = b != null ? b : 0;
c = c != null ? c : 0;
//...
}
foo("a", null, 2);
现在必须提供所有参数值，但默认值可能为null。
可选类。此方法类似于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());
可选为调用方显示方法契约，但是，可能会发现此类签名过于冗长。
更新：Java 8包含了开箱即用的类java.util.Optional，因此在Java 8中不需要为此特殊原因使用guava。但方法名称有点不同。
构建器模式。构建器模式用于构造函数，并通过引入单独的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();
地图。当参数数量过大且通常使用大多数默认值时，您可以将方法参数作为其名称/值的映射传递：
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 = (Integer)parameters.get("a");
}
if (parameters.containsKey("b")) {
//...
}
//...
}
foo(ImmutableMap.<String, Object>of(
"a", "a",
"b", 2,
"d", "value"));
在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"));
请注意，您可以结合使用这些方法中的任何一种来获得理想的效果。
答案 1 :(得分：466)
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag) {
...
}
public void doSomething() {
doSomething(defaultOptionalFlagValue);
}
答案 2 :(得分：100)
您可以使用以下内容：
public void addError(String path, String key, Object... params) {
}
params变量是可选的。它被视为可以为空的对象数组。
奇怪的是，我在文档中找不到任何相关内容，但它确实有效！
这在Java 1.5及更高版本中是“新的”（在Java 1.4或更早版本中不受支持）。
我看到用户bhoot也提到了这一点。
答案 3 :(得分：98)
Java 5.0中有可选参数。只需声明你的功能：
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
您现在可以使用doSomething();或doSomething(true);致电。
答案 4 :(得分：49)
不幸的是，Java不直接支持默认参数。
但是，我编写了一组JavaBean注释，其中一个支持默认参数，如下所示：
protected void process(
Processor processor,
String item,
@Default("Processor.Size.LARGE") Size size,
@Default("red") String color,
@Default("1") int quantity) {
processor.process(item, size, color, quantity);
}
public void report(@Default("Hello") String message) {
System.out.println("Message: " + message);
}
注释处理器生成方法重载以正确支持它。
请参阅http://code.google.com/p/javadude/wiki/Annotations
http://code.google.com/p/javadude/wiki/AnnotationsDefaultParametersExample
的完整示例答案 5 :(得分：47)
Java中没有可选参数。你可以做的是重载函数然后传递默认值。
void SomeMethod(int age, String name) {
//
}
// Overload
void SomeMethod(int age) {
SomeMethod(age, "John Doe");
}
答案 6 :(得分：21)
提到了VarArgs和重载。另一种选择是Builder模式，它看起来像这样：
MyObject my = new MyObjectBuilder().setParam1(value)
.setParam3(otherValue)
.setParam6(thirdValue)
.build();
虽然在构造函数中需要可选参数时，该模式最适合。
答案 7 :(得分：14)
在JDK＆gt; 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);
}
}
}
答案 8 :(得分：8)
这取决于你想要实现的目标，varargs或方法重载应该可以解决大多数情况。 这里有一些很好的例子，说明如何使用它们：
http://blog.sleekface.com/in/java-core/method-with-optional-parameters/
但请记住不要过度使用方法重载。它带来了混乱。
答案 9 :(得分：6)
使用三个点：
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的回答）
答案 10 :(得分：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...){}
答案 11 :(得分：3)
如果它是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 :(得分：2)
重载很好，但是如果有很多变量需要默认值，你最终会得到：
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。 这是link的解释。
答案 13 :(得分：1)
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
}
答案 14 :(得分：1)
您可以使用与构建器非常相似的类来包含这样的可选值。
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()方法，该方法不接受可选参数。
使用此方法，您可以按任何顺序指定可选值，而不会产生任何歧义。与varargs不同，您还可以使用不同类的参数。如果您可以使用注释和代码生成来创建Options类，那么这种方法会更好。
答案 15 :(得分：0)
我们可以通过Method overloading或Using DataType ...
创建可选参数| * |方法重载：
RetDtaTyp NamFnc(String NamPsgVar)
{
// |* CodTdo *|
return RetVar;
}
RetDtaTyp NamFnc(String NamPsgVar)
{
// |* CodTdo *|
return RetVar;
}
RetDtaTyp NamFnc(int NamPsgVar1, String NamPsgVar2)
{
// |* CodTdo *|
return RetVar;
}
最简单的方法是
| * | DataType ...可以是可选参数
RetDtaTyp NamFnc(int NamPsgVar, String... SrgOpnPsgVar)
{
if(SrgOpnPsgVar.length == 0) SrgOpnPsgVar = DefSrgVar;
// |* CodTdo *|
return RetVar;
}
答案 16 :(得分：0)
这是一个古老的问题，甚至在引入实际的Optional类型之前，但如今，您可以考虑以下几件事： -使用方法重载 -使用Optional类型，它具有避免在周围传递NULL的优点 可选类型是Java 8引入的，通常在第三方库（例如Google的Guava）中使用。使用可选参数作为参数/参数可以认为是过度使用，因为主要目的是将其用作返回时间。
答案 17 :(得分：0)
如果您计划使用具有多个参数的界面， 可以使用以下结构模式并实现或覆盖应用-一种基于您的要求的方法。
public abstract class Invoker<T> {
public T apply() {
return apply(null);
}
public abstract T apply(Object... params);
}
答案 18 :(得分：0)
默认参数不能在Java中使用。在C＃，C ++和Python中，我们可以使用它们。
在Java中，我们必须使用2个方法（函数）而不是使用默认参数的方法。
示例：
Stash(int size);
Stash(int size, int initQuantity);