我遇到了一些具有以下结构的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是否支持这种语法？有没有理由为什么这两步语法更可取？
答案 0 :(得分：843)
不，您找到的结构是Java如何处理它（即，使用重载而不是默认参数）。
对于构造函数， See Effective Java: Programming Language Guide's 第1项提示（如果重载变得复杂，则考虑使用静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象可能会有所帮助。这是因为当你有足够的复杂性时难以区分。一个明确的情况是你必须使用参数的顺序来区分，而不仅仅是数字和类型。
答案 1 :(得分：587)
不，但您可以使用Builder Pattern中所述的this Stack Overflow answer。
如链接答案中所述，Builder Pattern允许您编写类似
的代码Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
.name("Spicoli")
.age(16)
.motto("Aloha, Mr Hand")
.buildStudent();
其中某些字段可以具有默认值，或者是可选的。
答案 2 :(得分：409)
有几种方法可以在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());
可选为调用者显示方法契约，但是，人们可能会发现此类签名过于冗长。
构建器模式。构建器模式用于构造函数，并通过引入单独的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");
} else if (parameters.containsKey("b")) {
//...
}
//...
}
foo(ImmutableMap.<String, Object>of(
"a", "a",
"b", 2,
"d", "value"));
请注意，您可以结合使用这些方法中的任何一种来获得理想的效果。
答案 3 :(得分：220)
可悲的是，没有。
答案 4 :(得分：80)
不幸的是，是的。
void MyParameterizedFunction(String param1, int param2, bool param3=false) {}
可以用Java 1.5编写为：
void MyParameterizedFunction(String param1, int param2, Boolean... params) {
assert params.length <= 1;
bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}
但是，你是否应该依赖于你对生成
的编译器的看法new Boolean[]{}
每次通话。
对于多个可默认的参数：
void MyParameterizedFunction(String param1, int param2, bool param3=false, int param4=42) {}
可以用Java 1.5编写为：
void MyParameterizedFunction(String param1, int param2, Object... p) {
int l = p.length;
assert l <= 2;
assert l < 1 || Boolean.class.isInstance(p[0]);
assert l < 2 || Integer.class.isInstance(p[1]);
bool param3 = l > 0 && p[0] != null ? ((Boolean)p[0]).booleanValue() : false;
int param4 = l > 1 && p[1] != null ? ((Integer)p[1]).intValue() : 42;
}
这符合C ++语法，它只允许参数列表末尾的默认参数。
除了语法之外，还有一个不同之处在于它对传递的默认参数进行了运行时类型检查，而C ++类型在编译期间检查它们。
答案 5 :(得分：35)
不，但你可以很容易地模仿它们。 C ++中的内容是：
public: void myFunction(int a, int b=5, string c="test") { ... }
在Java中，它将是一个重载函数：
public void myFunction(int a, int b, string c) { ... }
public void myFunction(int a, int b) {
myFunction(a, b, "test");
}
public void myFunction(int a) {
myFunction(a, 5);
}
前面提到过，默认参数导致函数重载的模糊情况。这根本不是真的，我们可以在C ++的情况下看到：是的，也许它可以创建模糊的情况，但这些问题可以很容易地处理。它根本没有用Java开发，可能是因为创作者想要一种更简单的语言，因为C ++是 - 如果他们有正确的话，则是另一个问题。但是我们大多数人都不认为他使用Java是因为它很简单。
答案 6 :(得分：20)
您可以在Scala中执行此操作，Scala在JVM上运行并与Java程序兼容。 http://www.scala-lang.org/
即
class Foo(var prime: Boolean = false, val rib: String) {}
答案 7 :(得分：13)
代替使用：
curl -i -X PUT
-d "http://localhost:8080/feedback/1"
-H "Content-Type:text/uri-list" http://localhost:8080/product/1/feedbackProduct
您可以通过一个方法来利用Java的Optional功能：
void parameterizedMethod(String param1, int param2) {
this(param1, param2, false);
}
void parameterizedMethod(String param1, int param2, boolean param3) {
//use all three parameters here
}
主要区别在于，必须使用包装器类而不是原始Java类型来允许void parameterizedMethod(String param1, int param2, @Nullable Boolean param3) {
param3 = Optional.ofNullable(param3).orElse(false);
//use all three parameters here
}
输入。null代替Boolean，boolean代替{{ 1}}等。
答案 8 :(得分：11)
我可能会在这里说明显而易见但为什么不自己简单地实现“默认”参数？
public class Foo() {
public void func(String s){
func(s, true);
}
public void func(String s, boolean b){
//your code here
}
}
默认情况下，您将使用
func（“my string”）;
如果你不想使用默认值，你可以使用
func（“my string”，false）;
答案 9 :(得分：10)
否，但实施此的最简单方法是：
public myParameterizedFunction(String param1, int param2, Boolean param3) {
param3 = param3 == null ? false : param3;
}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);
}
或者代替三元运算符，您可以使用：
public myParameterizedFunction(String param1, int param2, Boolean param3) {
if (param3 == null) {
param3 = false;
}
}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);
}
答案 10 :(得分：6)
没有。一般来说，Java没有太多（任何）语法糖，因为他们试图制作一种简单的语言。
答案 11 :(得分：6)
没有。
您可以通过传递具有智能默认值的Object来实现相同的行为。但这又取决于你的情况。
答案 12 :(得分：4)
它不受支持，但有几个选项，比如使用带有一些语法糖的参数对象模式：
public class Foo() {
private static class ParameterObject {
int param1 = 1;
String param2 = "";
}
public static void main(String[] args) {
new Foo().myMethod(new ParameterObject() {{ param1 = 10; param2 = "bar";}});
}
private void myMethod(ParameterObject po) {
}
}
在此示例中，我们使用默认值构造ParameterObject并在类实例初始化部分{ param1 = 10; param2 = "bar";}
答案 13 :(得分：4)
提到Scala时，Kotlin也值得一提。在Kotlin中，函数参数也可以具有默认值，它们甚至可以引用其他参数：
href与Scala一样，Kotlin在JVM上运行，可以轻松集成到现有的Java项目中。
答案 14 :(得分：3)
试试这个解决方案：
public int getScore(int score, Integer... bonus)
{
if(bonus.length > 0)
{
return score + bonus[0];
}
return score;
}
答案 15 :(得分：2)
在Java 8中使用https://stackoverflow.com/a/13864910/2323964的类似方法是使用具有默认getter的接口。这将是更多的空白冗长，但是可以模仿，并且当你有一堆实例想要引起对参数的注意时，这很好。
public class Foo() {
public interface Parameters {
String getRequired();
default int getOptionalInt(){ return 23; }
default String getOptionalString(){ return "Skidoo"; }
}
public Foo(Parameters parameters){
//...
}
public static void baz() {
final Foo foo = new Foo(new Person() {
@Override public String getRequired(){ return "blahblahblah"; }
@Override public int getOptionalInt(){ return 43; }
});
}
}
答案 16 :(得分：2)
您可以使用Java Method Invocation Builder自动生成默认值的构建器。
只需将@GenerateMethodInvocationBuilder添加到类或接口，并将@Default添加到需要默认值的方法中的参数。将使用您在注释中指定的默认值在编译时生成构建器。
@GenerateMethodInvocationBuilder
public class CarService {
public CarService() {
}
public String getCarsByFilter(//
@Default("Color.BLUE") Color color, //
@Default("new ProductionYear(2001)") ProductionYear productionYear,//
@Default("Tomas") String owner//
) {
return "Filtering... " + color + productionYear + owner;
}
}
然后你可以调用这些方法。
CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
.invoke(instance);
或者将任何默认值设置为其他值。
CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
.withColor(Color.YELLOW)//
.invoke(instance);
答案 17 :(得分：1)
有六个或更好的问题，比如这个，最终你会到达静态工厂模式......请参阅crypto api。排序很难解释，但是这样想：如果你有一个构造函数，默认或其他，将状态传播到花括号之外的唯一方法是要有一个布尔值isValid; （以及null作为默认值v失败的构造函数）或抛出一个异常，从现场用户那里获取它时从不提供信息。
Code Correct被诅咒，我写了千行构造函数并做我需要的东西。我发现在对象构造中使用isValid - 换句话说，两个行构造函数 - 但由于某种原因，我正在迁移到静态工厂模式。我似乎你可以做很多事情，如果你在方法调用中，仍然存在sync（）问题，但默认值可以'替换'更好（更安全）
我认为我们需要做的是解决null作为默认值的问题，相对于某事物String one = new String（“”）;作为成员变量，然后在分配传递给构造函数的字符串之前检查null。
用Java完成的原始，平流层计算机科学的数量非常显着。
C ++等有供应商库，是的。由于它是庞大的工具箱，Java可以在大型服务器上超越它们。研究静态初始化块，与我们保持联系。
答案 18 :(得分：1)
这就是我这样做的方式......或许对你定义的参数有一个'可选参数'并不方便，但它完成了工作：
public void postUserMessage(String s,boolean wipeClean)
{
if(wipeClean)
{
userInformation.setText(s + "\n");
}
else
{
postUserMessage(s);
}
}
public void postUserMessage(String s)
{
userInformation.appendText(s + "\n");
}
注意我可以用一个字符串调用相同的方法名称，或者我可以用字符串和布尔值调用它。在这种情况下，将wipeClean设置为true将使用提供的字符串替换TextArea中的所有文本。将wipeClean设置为false或将它们全部放在一起只需将提供的文本附加到TextArea。
另请注意，我没有在这两种方法中重复代码，我只是添加了能够通过仅使用添加的布尔值创建具有相同名称的新方法来重置TextArea的功能。
我实际上认为这比Java为我们的参数提供'可选参数'更清洁，因为我们需要编写默认值等等。在这个例子中，我不需要担心任何一个。是的，我在课堂上添加了另一种方法，但从长远来看，以我的拙见更容易阅读。
答案 19 :(得分：1)
一个想法是使用String... args
public class Sample {
void demoMethod(String... args) {
for (String arg : args) {
System.out.println(arg);
}
}
public static void main(String args[] ) {
new Sample().demoMethod("ram", "rahim", "robert");
new Sample().demoMethod("krishna", "kasyap");
new Sample().demoMethod();
}
}
输出
ram
rahim
robert
krishna
kasyap
来自https://www.tutorialspoint.com/Does-Java-support-default-parameter-values-for-a-method
答案 20 :(得分：1)
如果确实需要，可以使用null手动检查它：
public MyParameterizedFunction(String param1, int param2, boolean param3)
{
if(param3 == null) {
param 3 = false;
}
}
但是，我强烈建议您使用其他方法，例如重载或静态工厂。也许您可以避免这种情况，但是它可能导致意外行为。例如，您的代码中可能存在错误，因此布尔值永远不会获得值。在这种情况下，您不会得到NullPointerException。相反，它看起来像是设置为false，这可能会使调试非常混乱。
答案 21 :(得分：0)
不，但我们还有函数重载的替代方法。
在没有传递参数时调用
void operation(){
int a = 0;
int b = 0;
}
在传递“a”参数时调用
void operation(int a){
int b = 0;
//code
}
在参数b传递时调用
void operation(int a , int b){
//code
}
答案 22 :(得分：0)
我现在已经花了很多时间来弄清楚如何将其与返回值的方法一起使用，到目前为止，我还没有看到任何示例，我认为在此处添加该示例可能会很有用：
render(){
this.props.children(value)
}
答案 23 :(得分：0)
在Java中不像在其他语言中一样支持它。科特林。
答案 24 :(得分：0)
您可以使用以下-
public void mop(Integer x) {
// Define default values
x = x == null ? 200 : x;
}