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如何处理它的（也就是说，使用重载而不是默认参数）

对于构造函数，如果重载变得复杂，第1项提示（考虑静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象会有所帮助。这是当你有足够的复杂性，区分是困难的。确切的情况是，您必须使用参数的顺序进行区分，而不仅仅是数字和类型。

否

---

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

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

否，但您可以使用，如中所述

如链接答案中所述，生成器模式允许您编写如下代码

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

---

其中一些字段可以有默认值，也可以是可选的。

有六个或更多类似的问题，最终，您会得到静态工厂模式。。。请参阅加密API以了解这一点。排序很难解释，但可以这样想：如果您有一个构造函数，默认值或其他值，那么将状态传播到大括号之外的唯一方法就是使用布尔值isValid；（连同null作为默认值v failed构造函数）或抛出一个异常，当从字段用户处获取它时，该异常永远不会提供信息

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

我认为我们在这里需要做的是解决null作为默认值与stringone=newstring（“”）的关系问题；作为成员变量，然后在将传递给构造函数的字符串赋值之前检查null

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

C++等等都有供应商库，是的。由于Java是一个庞大的工具箱，所以它可以在大型服务器上运行得比它们快。研究静态初始值设定项块，请与我们联系。

不幸的是，是的

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

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

每次打电话

对于多个默认参数：

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

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

可以用Java 1.5编写为：

void MyParameterizedFunction(String param1, int param2, Boolean... params) {
    assert params.length <= 1;
    bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}

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

void MyParameterizedFunction（字符串param1、int param2、对象…p）{
int l=p.长度；
断言l0&&p[0]！=null？（（布尔）p[0]）。booleanValue（）：false；
int param4=l>1&&p[1]！=null？（（整数）p[1]）。intValue（）：42；
}

这与C++语法匹配，它只允许参数列表末尾的默认参数。

---

超越语法，在运行时，对运行的默认参数进行检查，C++类型在编译时检查它们有区别。

< P>可以在Scala中执行，它在JVM上运行，与java程序兼容。

i、 e

---

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

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”；}

我可能在这里说明显而易见的问题，但为什么不自己实现“default”参数呢

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中模拟默认参数：

方法重载。

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

这种方法的一个局限性是，如果有两个相同类型的可选参数，并且其中任何一个都可以忽略，那么它就不起作用

Varargs.

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

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

可选类。此方法类似于nulls，但对具有默认值的参数使用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());

映射。当参数的数量太多并且通常使用默认值时，可以将方法参数作为其名称/值的映射传递：

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 foo（映射参数）{
字符串a=“”；
整数b=0；
if（parameters.containsKey（“a”）{
如果（！（parameters.get（“a”）instanceof Integer））{
抛出新的IllegalArgumentException（“…”）；
}
a=（字符串）参数.get（“a”）；
}else if（parameters.containsKey（“b”）{
//... 
}
//...
}
foo（不可变映射）(
“a”，“a”，
“b”，2，
“d”、“价值”）；

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

尝试以下解决方案：

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

前面提到过，默认参数会导致函数中出现不明确的情况

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

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;

} 

void operation(int a){

int b = 0;
//code

} 

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

public myParameterizedFunction(String param1, int param2, Boolean param3) {

    if (param3 == null) {
        param3 = false;
    }
}

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

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

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 mop(Integer x) {
  // Define default values
        x = 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
}

void parameterizedMethod(String param1, int param2, @Nullable Boolean param3) {
    param3 = Optional.ofNullable(param3).orElse(false);
    //use all three parameters here
}

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

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