Java 是否支持默认参数值？

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

对于构造函数，如果重载变得复杂，See Effective Java: Programming Language Guide's 第 1 项提示（考虑静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象会有所帮助。这是当你有足够的复杂性，难以区分的时候。一个明确的情况是您必须使用参数的顺序来区分，而不仅仅是数字和类型。

---

不可以，但您可以使用 Builder Pattern，如 this Stack Overflow answer 中所述。

如链接答案中所述，构建器模式可让您编写如下代码

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); // 这里，0 是 b 的默认值 } foo("a", 2);富（“一”）；这种方法的一个限制是，如果您有两个相同类型的可选参数并且其中任何一个都可以省略，则它不起作用。可变参数。 a) 所有可选参数的类型相同： void foo(String a, Integer... b) { Integer b1 = b.length > 0 ? b[0]：0；整数 b2 = b.length > 1 ？ b[1]：0； //... } foo("a"); foo("a", 1, 2); b) 可选参数的类型可能不同： void foo(String a, Object... b) { Integer b1 = 0;字符串 b2 = ""; if (b.length > 0) { if (!(b[0] instanceof Integer)) { throw new IllegalArgumentException("..."); } b1 = (整数)b[0]; } if (b.length > 1) { if (!(b[1] instanceof String)) { throw new IllegalArgumentException("..."); } b2 = (字符串)b[1]; //... } //... } foo("a"); foo("a", 1); foo("a", 1, "b2");这种方法的主要缺点是，如果可选参数的类型不同，您将失去静态类型检查。此外，如果每个参数具有不同的含义，您需要一些方法来区分它们。空值。为了解决以前方法的局限性，您可以允许空值，然后分析方法主体中的每个参数： void foo(String a, Integer b, Integer c) { b = b != null ?乙：0； c = c != 空？ c：0； //... } foo("a", null, 2);现在必须提供所有参数值，但默认值可能为空。选修课。这种方法类似于空值，但对具有默认值的参数使用 Java 8 Optional 类： void foo(String a, Optional bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.absent()); Optional 使调用者的方法契约明确，但是，人们可能会发现这样的签名过于冗长。生成器模式。 builder模式用于构造函数，通过引入一个单独的Builder类来实现：class Foo { private final String a;私人最终整数 b; Foo(String a, Integer b) { this.a = a;这个.b = b; } //... } 类 FooBuilder { 私有字符串 a = "";私人整数 b = 0; FooBuilder setA(String a) { this.a = a;返回这个； } FooBuilder setB(Integer b) { this.b = b;返回这个； } Foo build() { return new Foo(a, b); } } Foo foo = new FooBuilder().setA("a").build();地图。当参数的数量太多并且通常使用默认值时，您可以将方法参数作为其名称/值的映射传递： void foo(Map parameters) { String a = "" ;整数 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.of( "a", "a", "b", 2 , "d", "值"));

请注意，您可以结合使用这些方法中的任何一种来获得理想的结果。

---

可悲的是没有。

---

不幸的是，是的。

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

---

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

---

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

IE

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

---

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

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

---

而不是使用：

void parameterizedMethod(String param1, int param2) {
    this(param1, param2, false);
}

void parameterizedMethod(String param1, int param2, boolean param3) {
    //use all three parameters here
}

您可以通过使用一个方法来利用 java 的 Optional 功能：

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 等等。

---

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

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 中不受支持，就像在其他语言中一样。科特林。

---

正如提到的 Scala，Kotlin 也值得一提。在 Kotlin 中，函数参数也可以有默认值，它们甚至可以引用其他参数：

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

与 Scala 一样，Kotlin 在 JVM 上运行，可以轻松集成到现有的 Java 项目中。

---

不。一般来说，Java 没有太多（任何）语法糖，因为他们试图制作一种简单的语言。

---

不。

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

---

如果您确实需要，可以使用 null 手动检查：

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

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

---

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

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 int getScore(int score, Integer... bonus)
{
    if(bonus.length > 0)
    {
        return score + bonus[0];
    }

    return score;
}

---

您可以使用 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);

---

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

---

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

int foo(int a) {
    // do something with a
    return a;
}

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

---

这就是我的做法......它可能不如针对您定义的参数使用“可选参数”方便，但它可以完成工作：

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 为我们的参数提供一个“可选参数”要干净一些，因为我们需要为默认值等编写代码。在这个例子中，我不需要担心任何这些。是的，我在课堂上添加了另一种方法，但从长远来看，以我的拙见，它更容易阅读。

---

不，但是我们有函数重载形式的替代方案。

未传递参数时调用

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
} 

---

有六个或更好的问题，最终，你会到达静态工厂模式......请参阅加密 API。排序很难解释，但是这样想：如果你有一个构造函数，无论是默认的还是其他的，将状态传播到花括号之外的唯一方法是要么有一个布尔值 isValid； （连同 null 作为默认值 v 失败的构造函数）或抛出一个异常，从字段用户那里取回它时永远不会提供信息。

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

我认为我们需要在这里做的是解决 null 作为默认值相对于某些东西的问题 String one=new String("");作为成员变量，然后在分配传递给构造函数的字符串之前检查是否为空。

用 Java 完成的原始、平流层计算机科学的数量非常惊人。

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

---

一种想法是使用 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

---

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

---

您可以使用以下 -

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

---