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项技巧（考虑静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象可能会有所帮助。这是当您具有足够的复杂性而难以区分的时候。在一定情况下，您必须使用参数的顺序进行区分，而不仅仅是数字和类型。

不，但是您可以使用构建器模式，如本堆栈溢出答案中所述。

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

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

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

有几种方法可以模拟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. Varargs。

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

   现在必须提供所有参数值，但是默认值可以为null。

4. 可选类。这种方法类似于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());

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

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. 地图。当参数数量太大且通常使用大多数默认值时，可以将方法参数作为其名称/值的映射传递：

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

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

可悲的是没有。

不幸的是。

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是因为它简单。

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

即

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

我可能会在此处说明显而易见的内容，但为什么不自己直接实现“默认”参数呢？

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

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

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

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

没有。

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

否。一般而言，Java没有太多（任何）语法糖，因为它们试图创建一种简单的语言。

而不是使用：

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() {
    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方法调用构建器自动生成具有默认值的构建器。

只需将@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");
}

注意，我可以仅使用字符串来调用相同的方法名称，也可以使用字符串和布尔值来调用它。在这种情况下，将cleanClean设置为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
} 

出现了诸如此类的六个或更多问题，最终，您到达了静态工厂模式……有关该信息，请参见crypto API。排序很难解释，但是要这样想：如果您有构造函数（默认值或其他值），则将状态传播到花括号之外的唯一方法是使用布尔值isValid；（以及null作为默认值v失败的构造函数）或抛出异常，从现场用户处获取该异常永远不会提供信息。

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

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

用Java完成的原始，平流层计算机科学的数量非常可观。

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

Java不像其他语言一样支持它。科特林。

您可以使用以下内容-

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