Java可选参数

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


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

private boolean defaultOptionalFlagValue = true;

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

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

有几种方法可以模拟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");
    

    这种方法的局限性之一是,如果您有两个相同类型的可选参数并且它们中的任何一个都可以省略,则它不起作用。

  • 可变参数。

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

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

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

    可选方法为调用方明确了方法合同,但是,可能会发现这样的签名过于冗长。

    更新:Java 8包含了类java.util.Optional ,所以在java 8中不需要使用guava。方法名称虽然有点不同。

  • 建造者模式。 构建器模式用于构造函数,并通过引入一个单独的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();
    
  • 地图。 当参数的数量太大,并且通常使用大多数默认值时,可以将方法参数作为其名称/值的映射进行传递:

    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")); 
    
  • 请注意,您可以结合使用这些方法来获得理想的结果。


    你可以使用这样的东西:

    public void addError(String path, String key, Object... params) { 
    }
    

    params变量是可选的。 它被视为对象的可空数组。

    奇怪的是,我在文档中找不到任何关于此的内容,但它起作用!

    这是Java 1.5及更高版本中的“新”(Java 1.4或更早版本不支持)。

    我看到用户bhoot在下面提到了这一点。

    链接地址: http://www.djcxy.com/p/3545.html

    上一篇: Java optional parameters

    下一篇: Managing constructors with many parameters in Java