在Java中有几种模拟可选参数的方法:

方法重载。 void foo(字符串a，整数b) { / /…… ｝ void foo(字符串a) { foo (0);//这里，0是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");

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

null。为了解决前面方法的局限性，你可以允许空值，然后在方法体中分析每个参数: void foo(字符串a，整数b，整数c) { B = B != null ?B: 0; C = C != null ?C: 0; / /…… ｝ Foo ("a"， null, 2);

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

Optional class. This approach is similar to nulls, but uses Java 8 Optional class for parameters that have a default value: void foo(String a, Optional bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.absent()); Optional makes a method contract explicit for a caller, however, one may find such signature too verbose. Update: Java 8 includes the class java.util.Optional out-of-the-box, so there is no need to use guava for this particular reason in Java 8. The method name is a bit different though. Builder pattern. The builder pattern is used for constructors and is implemented by introducing a separate Builder class: 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(); Maps. When the number of parameters is too large and for most of the 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 = (Integer)parameters.get("a"); } if (parameters.containsKey("b")) { //... } //... } foo(ImmutableMap.<String, Object>of( "a", "a", "b", 2, "d", "value")); In Java 9, this approach became easier: @SuppressWarnings("unchecked") static <T> T getParm(Map<String, Object> map, String key, T defaultValue) { return (map.containsKey(key)) ? (T) map.get(key) : defaultValue; } void foo(Map<String, Object> parameters) { String a = getParm(parameters, "a", ""); int b = getParm(parameters, "b", 0); // d = ... } foo(Map.of("a","a", "b",2, "d","value"));

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

Java中没有可选参数。你能做的就是重载函数，然后传递默认值。

void SomeMethod(int age, String name) {
    //
}

// Overload
void SomeMethod(int age) {
    SomeMethod(age, "John Doe");
}

这是一个老问题，甚至在实际的可选类型引入之前，但现在你可以考虑以下几件事: -使用方法重载 - use可选类型，优点是避免传递空值 可选类型是在Java 8中引入的，通常是在第三方lib(如谷歌的Guava)中使用。使用optional作为参数/参数可能被认为是过度使用，因为主要目的是将其用作返回时间。

裁判:https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html

如果它是一个API端点，一种优雅的方法是使用“Spring”注释:

@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam(required = false, defaultValue = "hello") String id) { 
    return innerFunc(id);
}

注意在这个例子中，innerFunc将需要这个变量，因为它不是api端点，不能使用这个Spring注释使它成为可选的。 参考:https://www.baeldung.com/spring-request-param

变量函数可以(以某种方式)做到这一点。除此之外，必须提供方法声明中的所有变量。如果希望变量是可选的，可以使用不需要参数的签名重载方法。

private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) {
    ...
}

public void doSomething() {
    doSomething(defaultOptionalFlagValue);
}

简短版本:

用三个点:

public void foo(Object... x) {
    String first    =  x.length > 0 ? (String)x[0]  : "Hello";
    int duration    =  x.length > 1 ? Integer.parseInt((String) x[1])     : 888;
}   
foo("Hii", ); 
foo("Hii", 146); 

(根据@VitaliiFedorenko的回答)