如何在Java中使用可选参数？什么规范支持可选参数？

16 回答

重载很好，但如果有很多变量需要默认值，你最终会得到：

public void methodA(A arg1) {  }
public void methodA( B arg2,) {  }
public void methodA(C arg3) {  }
public void methodA(A arg1, B arg2) {  }
public void methodA(A arg1, C arg3) {  }
public void methodA( B arg2, C arg3) {  }
public void methodA(A arg1, B arg2, C arg3) {  }

所以我建议使用Java提供的Variable Argument . 这是link的解释 .

回复于 2024-04-26T15:21:46+08:00

426

Java现在支持1.8中的选项，我坚持使用android上的编程，所以我使用空值，直到我可以重构代码以使用可选类型 .

Object canBeNull() {
    if (blah) {
        return new Object();
    } else {
        return null;
    }
}

Object optionalObject = canBeNull();
if (optionalObject != null) {
    // new object returned
} else {
    // no new object returned
}

回复于 2024-04-26T15:21:46+08:00

47
varargs可以做到这一点（在某种程度上） . 除此之外，必须提供方法声明中的所有变量 . 如果希望变量是可选的，则可以使用不需要参数的签名重载方法 .
```
private boolean defaultOptionalFlagValue = true;

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

public void doSomething() {
    doSomething(defaultOptionalFlagValue);
}
```
回复于 2024-04-26T15:21:46+08:00

有几种方法可以在Java中模拟可选参数：

Method overloading.

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.

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

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

Nulls. 要解决以前方法的局限性，可以允许空值，然后分析方法体中的每个参数：

void foo(String a, Integer b, Integer c) {
    b = b != null ? b : 0;
    c = c != null ? c : 0;
    //...
}

foo("a", null, 2);

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

Optional class. 此方法类似于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());

可选为调用者显示方法 Contract ，但是，人们可能会发现这样的签名过于冗长 .

更新：Java 8包含了类 java.util.Optional 开箱即用的类，因此在Java 8中不需要为此特殊原因使用guava . 但方法名称有点不同 .

Builder pattern. 构建器模式用于构造函数，并通过引入单独的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();

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

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

在Java 9中，这种方法变得更容易：

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

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

回复于 2024-04-26T15:21:46+08:00

13
你可以使用这样的东西：
```
public void addError(String path, String key, Object... params) { 
}
```
params 变量是可选的 . 它被视为可以为对象的可空数组 .

奇怪的是，我在文档中找不到任何相关内容，但它确实有效！

这在Java 1.5及更高版本中是“新的”（Java 1.4或更早版本不支持） .

我看到用户bhoot也提到了这一点 .
回复于 2024-04-26T15:21:46+08:00
6
Java 5.0有可选参数 . 只需声明你的函数：
```
public void doSomething(boolean... optionalFlag) {
    //default to "false"
    //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
```
你现在可以用 doSomething(); 或 doSomething(true); 来打电话 .
回复于 2024-04-26T15:21:46+08:00

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

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

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

回复于 2024-04-26T15:21:46+08:00

4
遗憾的是，Java不直接支持默认参数 .

但是，我编写了一组JavaBean注释，其中一个支持默认参数，如下所示：
```
protected void process(
        Processor processor,
        String item,
        @Default("Processor.Size.LARGE") Size size,
        @Default("red") String color,
        @Default("1") int quantity) {
    processor.process(item, size, color, quantity);
}
public void report(@Default("Hello") String message) {
    System.out.println("Message: " + message);
}
```
注释处理器生成方法重载以正确支持它 .

见http://code.google.com/p/javadude/wiki/Annotations

http://code.google.com/p/javadude/wiki/AnnotationsDefaultParametersExample的完整示例
回复于 2024-04-26T15:21:46+08:00

已经提到了VarArgs和重载 . 另一种选择是Builder模式，它看起来像这样：

MyObject my = new MyObjectBuilder().setParam1(value)
                                 .setParam3(otherValue)
                                 .setParam6(thirdValue)
                                 .build();

虽然该模式最适合在构造函数中需要可选参数时 .

回复于 2024-04-26T15:21:46+08:00

在JDK> 1.5中，您可以像这样使用它;

public class NewClass1 {

    public static void main(String[] args) {

        try {
            someMethod(18); // Age : 18
            someMethod(18, "John Doe"); // Age & Name : 18 & John Doe
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void someMethod(int age, String... names) {

        if (names.length > 0) {
            if (names[0] != null) {
                System.out.println("Age & Name : " + age + " & " + names[0]);
            }
        } else {
            System.out.println("Age : " + age);
        }
    }
}

回复于 2024-04-26T15:21:46+08:00

1

这取决于你想要实现什么，varargs或方法重载应该解决大多数情况 .

但请记住不要过度使用方法重载 . 它带来了混乱 .

回复于 2024-04-26T15:21:46+08:00

短版：

使用 three dots ：

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

回复于 2024-04-26T15:21:46+08:00

97
你可以像这样使用方法重载做事 .
```
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...){}
```
回复于 2024-04-26T15:21:46+08:00

您可以使用类似于构建器的类来包含这样的可选值 .

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类，那么这种方法会更好 .

回复于 2024-04-26T15:21:46+08:00

1
Default arguments can not be used in Java and C#. Where in C++ and Python, we can use them..

在Java中，我们必须使用2个方法（函数）而不是一个使用默认参数 .

例：
```
Stash(int size); 

Stash(int size, int initQuantity);
```
http://parvindersingh.webs.com/apps/forums/topics/show/8856498-java-how-to-set-default-parameters-values-like-c-
回复于 2024-04-26T15:21:46+08:00

1447

我们可以通过Method重载或使用DataType来创建可选参数...

| * |方法重载：

RetDtaTyp NamFnc(String NamPsgVar)
{
    // |* CodTdo *|
    return RetVar;
}

RetDtaTyp NamFnc(String NamPsgVar)
{
    // |* CodTdo *|
    return RetVar;
}

RetDtaTyp NamFnc(int NamPsgVar1, String NamPsgVar2)
{
    // |* CodTdo *|
    return RetVar;
}

最简单的方法是

| * | DataType ...可以是可选参数

RetDtaTyp NamFnc(int NamPsgVar, String... SrgOpnPsgVar)
{
    if(SrgOpnPsgVar.length == 0)  SrgOpnPsgVar = DefSrgVar; 

    // |* CodTdo *|
    return RetVar;
}

回复于 2024-04-26T15:21:46+08:00

Java可选参数

16 回答

短版：

相关问题