您可以使用类似于构建器的类来包含可选值，如下所示。

public class Options {
    private String someString = "default value";
    private int someInt= 0;
    public Options setSomeString(String someString) {
        this.someString = someString;
        return this;
    }
    public Options setSomeInt(int someInt) {
        this.someInt = someInt;
        return this;
    }
}

public static void foo(Consumer<Options> consumer) {
    Options options = new Options();
    consumer.accept(options);
    System.out.println("someString = " + options.someString + ", someInt = " + options.someInt);
}

使用像

foo(o -> o.setSomeString("something").setSomeInt(5));

输出是

someString = something, someInt = 5

要跳过所有可选值，你必须像foo(o ->{})那样调用它;或者，如果您愿意，可以创建第二个foo()方法，该方法不接受可选参数。

使用这种方法，您可以以任何顺序指定可选值，而不会产生任何歧义。与varargs不同，你也可以有不同类的参数。如果可以使用注释和代码生成来创建Options类，这种方法就更好了。

你可以像这样使用方法重载。

 public void load(String name){ }

 public void load(String name,int age){}

你也可以使用@Nullable注释

public void load(@Nullable String name,int age){}

简单地传递null作为第一个参数。

如果你传递相同类型的变量，你可以使用这个

public void load(String name...){}

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

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

如果它是一个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

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

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

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

简短版本:

用三个点:

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的回答)