有六个或更好的问题，例如，最终，你会发现静态工厂模式。。。请参见加密API。排序很难解释，但可以这样想：如果您有构造函数，默认值或其他值，那么传播状态超出大括号的唯一方法是使用Boolean isValid；（以及null作为默认值v失败的构造函数）或抛出一个异常，当从字段用户处获取该异常时，该异常永远不会提供信息。

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

我认为我们需要做的是解决空值作为默认值相对于字符串一=新字符串（“”）的问题；作为成员变量，然后在将字符串分配给构造函数之前检查null。

在Java中完成了大量原始的、同温层的计算机科学。

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

类似的方法https://stackoverflow.com/a/13864910/2323964在Java8中工作的是使用带有默认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; }
        });
    }
}

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

方法重载。void foo（字符串a，整数b）{//...}void foo（字符串a）{foo（a，0）；//这里，0是b的默认值}foo（“a”，2）；foo（“a”）；这种方法的一个限制是，如果您有两个相同类型的可选参数，并且可以省略其中的任何一个，那么它就不起作用。变量。a） 所有可选参数的类型相同：void foo（字符串a，整数…b）{整数b1=b.length>0？b[0]：0；整数b2=b.length>1？b[1]:0；//...}foo（“a”）；foo（“a”，1，2）；b） 可选参数的类型可能不同：void foo（字符串a，对象…b）{整数b1=0；字符串b2=“”；如果（b.length>0）{if（！（b[0]instanceof Integer））｛抛出新的IllegalArgumentException（“…”）；}b1=（整数）b[0]；}如果（b.长度>1）{if（！（b[1]instanceof String））｛抛出新的IllegalArgumentException（“…”）；}b2=（字符串）b[1]；//...}//...}foo（“a”）；foo（“a”，1）；foo（“a”，1，“b2”）；这种方法的主要缺点是，如果可选参数的类型不同，则会丢失静态类型检查。此外，如果每个参数具有不同的含义，则需要一些方法来区分它们。Null。为了解决前面方法的局限性，可以允许空值，然后分析方法体中的每个参数：void foo（字符串a、整数b、整数c）{b=b！=无效的b:0；c=c！=无效的c:0；//...}foo（“a”，null，2）；现在必须提供所有参数值，但默认值可能为空。可选类。这种方法类似于null，但对具有默认值的参数使用Java 8 Optional类：void foo（字符串a，可选＜整数＞bOpt）{整数b=bOpt.isPresent（）？bOpt.get（）：0；//...}foo（“a”，可选，第（2）项）；foo（“a”，可选。＜Integer＞absent（））；可选使方法契约对调用方显式，但是，可能会发现这种签名过于冗长。生成器模式。生成器模式用于构造函数，通过引入单独的生成器类来实现：Foo类{private final字符串a；私有最终整数b；Foo（字符串a，整数b）{这个.a=a；此.b=b；}//...}类FooBuilder{private字符串a=“”；私有整数b=0；FooBuilder setA（字符串a）{这个.a=a；返回此；}FooBuilder集合b（整数b）{此.b=b；返回此；}Foo build（）{返回新的Foo（a，b）；}}Foo Foo=新建FooBuilder（）.setA（“a”）.build（）；地图。当参数的数量太大并且大多数参数通常使用默认值时，可以将方法参数作为其名称/值的映射传递：void foo（Map＜String，Object＞参数）{字符串a=“”；整数b=0；if（parameters.containsKey（“a”））｛if（！（parameters.get（“a”）instanceof Integer））｛抛出新的IllegalArgumentException（“…”）；}a=（字符串）参数.get（“a”）；}否则如果（parameters.containsKey（“b”））｛//... }//...}foo（ImmutableMap.＜String，Object＞of(“a”、“a”，“b”，2，“d”、“值”）；

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

直接的答案是否定的。

这些答案相当陈旧，主要讨论了即使java没有直接的默认方法参数，我们也可以选择哪些选项。

我们可以用java中的函数式编程轻松地处理这个场景。

我们可以使用java函数式编程的方法currying，我认为它可以最好地用于需要使用默认参数的场景。

在以下情况下，我们可能需要一个默认参数。。。例子：创建一个对两个不同对象有效的方法，并返回计算结果

int mutiply(int a,int b){

      return a*b;

  }

如果我们想有一个乘2的方法，我们必须重写如下方法

int mutiply(int a){

      mutiply(a, 2); // as can not write mutiply(int a,b=2)

  }

上面，2是b的默认值，但它是固定的。如果我们想乘以3，现在我们不能再重载了，而且有多个这样的方法确实很奇怪。

这是我们可以使用方法currying技术的时候。

Currying方法是将多参数函数转换为多个函数的方法，每个函数都接受一个参数。

创建Curried方法的步骤

编写一个接受单个参数并返回另一个参数的函数函数，如下所示。函数<Integer，函数<Integer>>multiply=a->{返回b->a*b；};让我们简化并理解上述方法。

Above方法只接受一个整数Argument，并返回另一个函数，其中一个参数a作为默认值，b作为变量。如果您感到困惑，并开始思考该方法如何使用调用者函数中的变量，而不知道闭包…

“闭包是指在其词汇上下文中引用自由变量的函数。”在这里，在本例中，闭包是对变量multiply进行操作时返回的函数，它有一个自由变量a，它具有调用函数的词法上下文。

返回乘法方法或修复其中一个参数的默认值。//乘法在第一步中定义multiplyByTwo=多重应用（2）multiplyByThree=multiply.apply（3）；multiplyByFour=多重应用（4）；；等等…将第二个变量传递给返回的函数以获得结果。multiplyByTwo.apply（2）//后果multiplyByTwo.apply（3）//结果6multiplyByThree.应用（2）//结果6multiplyByThree.应用（3）//结果9multiplyByFour.应用（2）//结果8multiplyByFour.应用（3）//结果124

你可以在这里找到我的原始帖子。。。https://www.linkedin.com/pulse/can-we-have-default-method-parameter-java-rajat-singh/?trackingId=yW84I1fzT6WGStrNPAWn4w%3D%3D

不，但你可以很容易地模仿它们。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 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);