Java是否支持默认参数值？

很遗憾，没有。

不，您找到的结构是Java处理它的方式（即重载而不是默认参数）。

对于构造函数，参见有效Java：编程语言指南第1项提示（考虑静态工厂方法而不是构造函数）

如果重载变得复杂。对于其他方法，重命名某些情况或使用参数对象可能会有所帮助。

这是当你有足够的复杂性时，区分是困难的。一个明确的情况是，你必须使用参数的顺序来区分，而不仅仅是数量和类型。

不。

您可以通过传递具有智能默认值的Object来实现相同的行为。但这同样取决于您手头的情况。

一般来说Java没有太多的语法糖，因为他们试图创造一种简单的语言。

不能，但您可以使用生成器模式，如这个堆栈溢出的答案所述。

如链接答案中所述，Builder模式允许您编写类似于

Student s1 = new StudentBuilder().name("Eli").buildStudent();Student s2 = new StudentBuilder().name("Spicoli").age(16).motto("Aloha, Mr Hand").buildStudent();

其中某些字段可以具有默认值或以其他方式是可选的。

有六个或更好的问题，比如这个，最终，你会得到静态工厂模式……参见加密API。很难解释，但可以这样想：如果你有一个构造函数，默认或其他，传播状态超出花括号的唯一方法是要么有一个布尔isValid；（以及null作为默认值v失败的构造函数），要么在从字段用户那里获取它时抛出一个永远不会提供信息的异常。

代码正确，我写了一千行构造函数并做了我需要的。我发现在对象构造中使用isValid——换句话说，两行构造函数——但出于某种原因，我正在迁移到静态工厂模式。如果你在方法调用中，仍然存在sync（）问题，但默认值可以更好（更安全），我似乎可以做很多事情

我认为我们在这里需要做的是解决null作为默认值与String one=new String（""）；作为成员变量的问题，然后在将字符串传递给构造函数之前检查null。

非常了不起的原始数量，平流层计算机科学在Java完成。

C++等等有供应商库，是的。Java可以在大型服务器上超越它们，因为它是一个巨大的工具箱。学习静态初始化器块，和我们在一起。

不幸的是，是的。

void MyParameterizedFunction(String param1, int param2, bool param3=false) {}

在Java1.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) {}

在Java1.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++类型在编译期间检查它们。

您可以在Scala中执行此操作，它在JVM上运行并与Java程序兼容。http://www.scala-lang.org/

即

class Foo(var prime: Boolean = false, val rib: String)  {}

它不受支持，但有几个选项，例如使用带有一些语法糖的参数对象模式：

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";}中覆盖它们

我可能在这里陈述显而易见的事实，但为什么不自己简单地实现“默认”参数呢？

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);

有几种方法可以模拟Java中的默认参数：

1. 方法重载。

   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");

   这种方法的局限性之一是，如果您有两个相同类型的可选参数并且可以省略其中任何一个，则它不起作用。

2. 瓦格斯。

   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");

   这种方法的主要缺点是，如果可选参数的类型不同，您将失去静态类型检查。此外，如果每个参数都有不同的含义，您需要某种方法来区分它们。

3. 空。为了解决前面方法的局限性，您可以允许空值，然后分析方法体中的每个参数：

   void foo(String a, Integer b, Integer c) {b = b != null ? b : 0;c = c != null ? c : 0;//...}
   foo("a", null, 2);

   现在必须提供所有参数值，但默认值可能为空。

4. 可选类。此方法类似于null，但对具有默认值的参数使用Java8可选类：

   void foo(String a, Optional<Integer> bOpt) {Integer b = bOpt.isPresent() ? bOpt.get() : 0;//...}
   foo("a", Optional.of(2));foo("a", Optional.<Integer>absent());

   可选使调用者的方法契约显式化，但是，人们可能会发现这样的签名过于冗长。

5. 生成器模式。构建器模式用于构造函数，并通过引入一个单独的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();

6. Maps. When the number of parameters is too large and for most of them default values are usually used, you can pass method arguments as a map of their names/values:

   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"));

Please note that you can combine any of these approaches to achieve a desirable result.

试试这个解决方案：

public int getScore(int score, Integer... bonus){if(bonus.length > 0){return score + bonus[0];}
return score;}

不，但是你可以很容易地模仿他们。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不是因为它的简单性。

我就是这样做的……它可能不像对定义的参数使用“可选参数”那么方便，但它完成了工作：

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提供了一个“可选参数”为我们的参数，因为我们将需要然后代码的默认值等在这个例子中，我不需要担心任何的，是的，我添加了另一个方法到我的类，但它更容易阅读从长远来看，我的愚见。

您可以使用Java方法调用生成器自动生成默认值的生成器。

只需在类或接口中添加@GenerateomeodInvocationBuilder，并在您需要默认值的方法中添加@Default到参数。将在编译时使用您在注释中指定的默认值生成构建器。

@GenerateMethodInvocationBuilderpublic 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);

在Java8中，与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; }});}}

否，但我们有替代形式的函数重载。

未传递参数时调用

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}

不，但最简单的实现方法是：

public myParameterizedFunction(String param1, int param2, Boolean param3) {
param3 = param3 == null ? false : param3;}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);}

或而不是三元算子，您可以使用if：

public myParameterizedFunction(String param1, int param2, Boolean param3) {
if (param3 == null) {param3 = false;}}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);}

正如Scala提到的，静态编程语言也值得一提。在静态编程语言中，函数参数也可以有默认值，甚至可以引用其他参数：

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {...}

与Scala一样，静态编程语言在JVM上运行，可以轻松集成到现有的Java项目中。

我现在花了相当多的时间来弄清楚如何将它与返回值的方法一起使用，到目前为止我还没有看到任何示例，我认为在这里添加这个可能会很有用：

int foo(int a) {// do something with areturn a;}
int foo() {return foo(0); // here, 0 is a default value for a}

它在java中不支持其他语言，例如静态编程语言。

你可使用以下方法─

public void mop(Integer x) {// Define default valuesx = x == null ? 200 : x;}

而不是使用：

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}

主要区别在于，您必须使用包装类而不是原始Java类型来允许null输入。Boolean而不是boolean，Integer而不是int等等。

一个想法是使用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();}}

产出

ramrahimrobertkrishnakasyap

从https://www.tutorialspoint.com/Does-Java-support-default-parameter-values-for-a-method

如果你真的想，你可以使用null手动检查它：

public MyParameterizedFunction(String param1, int param2, boolean param3){if(param3 == null) {param3 = false;}}

然而，我强烈建议使用其他东西，比如重载或静态工厂。也许你可以逃脱惩罚，但它会导致不可原谅的行为。例如，你的代码中可能有一个错误，所以你的布尔值永远不会得到一个值。在这种情况下，你不会得到一个NullPointerException。相反，它看起来像是被设置为false，这可能会让调试非常混乱。

构造函数like for方法

static void popuping() {popuping("message", "title");}static void popuping(String message) {popuping(message, "title");}static void popuping(String message, String title){JOptionPane.showMessageDialog(null, message,title, JOptionPane.INFORMATION_MESSAGE);}

是=使用静态编程语言！））））

这是一个笑话；