Vit*_*nko 1595
有几种方法可以在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");
这种方法的主要缺点是,如果可选参数属于不同类型,则会丢失静态类型检查.此外,如果每个参数具有不同的含义,您需要某种方式来区分它们.
空值.要解决先前方法的局限性,您可以允许空值,然后分析方法体中的每个参数:
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"));
请注意,您可以结合使用这些方法中的任何一种来获得理想的结果.
lag*_*neb 486
varargs可以做到这一点(在某种程度上).除此之外,必须提供方法声明中的所有变量.如果希望变量是可选的,则可以使用不需要参数的签名重载方法.
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag) {
...
}
public void doSomething() {
doSomething(defaultOptionalFlagValue);
}
小智 102
Java 5.0有可选参数.只需声明你的函数:
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
你可以打电话doSomething();或doSomething(true);现在打电话.
the*_*reg 101
你可以使用这样的东西:
public void addError(String path, String key, Object... params) {
}
该params变量是可选的.它被视为可以为对象的可空数组.
奇怪的是,我在文档中找不到任何相关内容,但它确实有效!
这在Java 1.5及更高版本中是"新的"(Java 1.4或更早版本不支持).
我看到用户bhoot也提到了这一点.
Sco*_*eld 52
遗憾的是,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上的完整示例
Dar*_*rio 49
Java中没有可选参数.你可以做的是重载函数然后传递默认值.
void SomeMethod(int age, String name) {
//
}
// Overload
void SomeMethod(int age) {
SomeMethod(age, "John Doe");
}
Yis*_*hai 22
已经提到了VarArgs和重载.另一种选择是Builder模式,它看起来像这样:
MyObject my = new MyObjectBuilder().setParam1(value)
.setParam3(otherValue)
.setParam6(thirdValue)
.build();
虽然该模式最适合在构造函数中需要可选参数时.
az3*_*az3 14
在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);
}
}
}
使用 三个点:
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的回答)
您可以使用这样的方法重载来做事情。
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...){}
小智 5
重载很好，但是如果有很多变量需要默认值，你最终会得到：
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提供的变量参数。