Java是否支持默认参数值？
我遇到了一些具有以下结构的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是否支持这种语法？ 有没有任何理由为什么这两个步骤的语法是可取的？
不，您发现的结构是Java如何处理它（即，使用重载而不是默认参数）。
对于构造函数，如果过载变得复杂，请参阅有效的Java：编程语言指南的第1项技巧（考虑静态工厂方法而不是构造函数）。 对于其他方法，重命名某些情况或使用参数对象可以提供帮助。 这是当你有足够的复杂性，差异化是困难的。 一个确定的情况是你必须使用参数顺序进行区分，而不仅仅是数字和类型。
不，但您可以使用Builder模式，如此堆栈溢出答案中所述。
正如链接答案中所述，Builder模式允许您编写类似的代码
Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
.name("Spicoli")
.age(16)
.motto("Aloha, Mr Hand")
.buildStudent();
其中一些字段可以具有默认值或者是可选的。
有几种方法可以模拟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);
现在必须提供所有参数值，但默认值可能为空。
可选课程。 此方法类似于空值，但对于具有默认值的参数使用Java 8可选类：
void foo(String a, Optional<Integer> bOpt) {
Integer b = bOpt.isPresent() ? bOpt.get() : 0;
//...
}
foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());
可选方法为调用方明确了方法合同，但是，可能会发现这样的签名过于冗长。
建造者模式。 构建器模式用于构造函数，并通过引入一个单独的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 = (String)parameters.get("a");
}
if (parameters.containsKey("b")) {
//...
}
//...
}
foo(ImmutableMap.<String, Object>of(
"a", "a",
"b", 2,
"d", "value"));
请注意，您可以结合使用这些方法来获得理想的结果。
链接地址: http://www.djcxy.com/p/463.html