提问



我遇到了一些具有以下结构的Java代码:


public MyParameterizedFunction(String param1, int param2)
{
    this(param1, param2, false);
}

public MyParameterizedFunction(String param1, int param2, boolean param3)
{
    //use all three parameters here
}


我知道在C ++中我可以为参数指定一个默认值。例如:


void MyParameterizedFunction(String param1, int param2, bool param3=false);


Java是否支持这种语法?有没有理由说这两步语法更可取?

最佳参考


不,您找到的结构是Java如何处理它(即,使用重载而不是默认参数)。


对于构造函数,如果重载变得复杂,参见Effective Java:Programming Language Guides Item 1 tip(考虑静态工厂方法而不是构造函数)。对于其他方法,重命名某些情况或使用参数对象当你有足够的复杂性来区分困难时,这是一个明确的案例,你必须使用参数的顺序来区分,而不仅仅是数字和类型。[35]

其它参考1


不,但您可以使用构建器模式,如此Stack Overflow答案中所述。[36]


如链接答案中所述,Builder Pattern允许您编写类似的代码


Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
                 .name("Spicoli")
                 .age(16)
                 .motto("Aloha, Mr Hand")
                 .buildStudent();


其中某些字段可以具有默认值,或者是可选的。

其它参考2


有几种方法可以在Java中模拟默认参数:



  1. 方法重载。


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


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

  2. 可变参数。


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


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

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


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


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

  4. 可选类。此方法类似于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());
    


    可选为调用者显示方法契约,但是,人们可能会发现这样的签名过于冗长。

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

  6. 地图。当参数数量太大且通常使用默认值时,您可以将方法参数作为其名称/值的映射传递:


    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 = (String)parameters.get("a");
        } else if (parameters.containsKey("b")) { 
            //... 
        }
        //...
    }
    
    foo(ImmutableMap.<String, Object>of(
        "a", "a",
        "b", 2, 
        "d", "value")); 
    



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

其它参考3


可悲的是没有。

其它参考4


不幸的是,是的。


void MyParameterizedFunction(String param1, int param2, bool param3=false) {}


可以用Java 1.5编写为:


void MyParameterizedFunction(String param1, int param2, Boolean... params) {
    assert params.length <= 1;
    bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}


但是,你是否应该依赖于你对编译器生成的感觉


new Boolean[]{}


每次通话。


对于多个默认参数:


void MyParameterizedFunction(String param1, int param2, bool param3=false, int param4=42) {}


可以用Java 1.5编写为:


void MyParameterizedFunction(String param1, int param2, Object... p) {
    int l = p.length;
    assert l <= 2;
    assert l < 1 || Boolean.class.isInstance(p[0]);
    assert l < 2 || Integer.class.isInstance(p[1]);
    bool param3 = l > 0 && p[0] != null ? ((Boolean)p[0]).booleanValue() : false;
    int param4 = l > 1 && p[1] != null ? ((Integer)p[1]).intValue() : 42;
}


这符合C ++语法,它只允许参数列表末尾的默认参数。


除了语法之外,还有一个区别在于它对传递的默认参数进行了运行时类型检查,而C ++类型在编译期间检查它们。

其它参考5


不,但你可以很容易地模仿它们。 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是因为它简单。

其它参考6


您可以在Scala中执行此操作,Scala在JVM上运行并与Java程序兼容。
http://www.scala-lang.org/[38]





class Foo(var prime: Boolean = false, val rib: String)  {}

其它参考7


我可能会在这里说明显而易见但是为什么不自己简单地实现默认参数?


public class Foo() {
        public void func(String s){
                func(s, true);
        }
        public void func(String s, boolean b){
                //your code here
        }
}


默认情况下,您将使用以太


func(我的字符串);


如果你不想使用默认值,你会使用


func(my string,false);

其它参考8


没有。一般来说,Java没有太多(任何)语法糖,因为他们试图制作一种简单的语言。

其它参考9


没有。


您可以通过传递具有智能默认值的Object来实现相同的行为。但这又取决于你的情况。

其它参考10


提到Scala时,Kotlin也值得一提。在Kotlin中,函数参数也可以有默认值,它们甚至可以引用其他参数:[39]


fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    ...
}


与Scala一样,Kotlin在JVM上运行,可以轻松集成到现有的Java项目中。

其它参考11


它不受支持,但有几个选项,如使用参数对象模式与一些语法糖:


public class Foo() {
    private static class ParameterObject {
        int param1 = 1;
        String param2 = "";
    }

    public static void main(String[] args) {
        new Foo().myMethod(new ParameterObject() {{ param1 = 10; param2 = "bar";}});
    }

    private void myMethod(ParameterObject po) {
    }
}


在此示例中,我们使用默认值构造ParameterObject并在类实例初始化部分{ param1 = 10; param2 = "bar";}中覆盖它们

其它参考12


试试这个解决方案


public int getScore(int score, Integer... bonus)
{
    if(bonus.length > 0)
    {
        return score + bonus[0];
    }

    return score;
}

其它参考13


,但实施此的最简单方法是:


public MyParameterizedFunction(String param1, int param2, Boolean param3) {

    param3 = param3 == null ? false : param3;
}

public MyParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}


或者代替三元运算符,您可以使用:


public MyParameterizedFunction(String param1, int param2, Boolean param3) {

    if (param3 == null) {
        param3 = false;
    }
}

public MyParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

其它参考14


有六个或更好的问题,比如这个,最终你到达静态工厂模式......看到加密api。排序难以解释,但可以这样考虑:如果你有一个构造函数,默认或其他,在大括号之外传播状态的唯一方法是要有一个布尔值isValid; (以及null作为默认值v失败的构造函数)或抛出一个异常,从现场用户获取它时从不提供信息。


Code Correct被诅咒,我写了千行构造函数并做我需要的。我发现在对象构造中使用isValid - 换句话说,两个行构造函数 - 但由于某种原因我正在迁移到静态工厂模式。我似乎你可以做很多,如果你在方法调用中,仍然有sync()问题,但默认值可以替换更好(更安全)


我认为我们需要做的是解决null作为默认值的问题,对象是一个String String=new String();作为成员变量,然后在分配传递给构造函数的字符串之前检查null。


用Java完成的原始,平流层计算机科学的数量是非常了不起的。


C ++等有供应商库,是的。由于它是庞大的工具箱,Java可以在大型服务器上超越它们。研究静态初始化程序块,留在我们身边。

其它参考15


这就是我这样做的方式......它不像对你定义的参数有一个可选参数那么方便,但它可以完成工作:


public void postUserMessage(String s,boolean wipeClean)
{
    if(wipeClean)
    {
        userInformation.setText(s + "\n");
    }
    else
    {
        postUserMessage(s);
    }
}

public void postUserMessage(String s)
{
    userInformation.appendText(s + "\n");
}


注意我可以用一个字符串调用相同的方法名称,或者我可以用字符串和布尔值调用它。在这种情况下,将wipeClean设置为true将使用提供的字符串替换TextArea中的所有文本。将wipeClean设置为false或将其全部放在一起只需将提供的文本附加到TextArea即可。


另请注意,我不是在两种方法中重复代码,我只是添加了能够通过仅使用添加的布尔值创建具有相同名称的新方法来重置TextArea的功能。


我实际上认为这比Java为我们的参数提供可选参数更清除,因为我们需要编写默认值等等。在这个例子中,我不需要担心任何这些。是的,我在课堂上添加了另一种方法,但从长远来看,我的拙见更容易阅读。

其它参考16


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

其它参考17


您可以使用Java方法调用构建器自动生成具有默认值的构建器。[41]


只需将@GenerateMethodInvocationBuilder添加到类或接口,将@Default添加到需要默认值的方法中的参数。将使用您在注释中指定的默认值在编译时生成构建器。


@GenerateMethodInvocationBuilder
public class CarService {
 public CarService() {
 }

 public String getCarsByFilter(//
   @Default("Color.BLUE") Color color, //
   @Default("new ProductionYear(2001)") ProductionYear productionYear,//
   @Default("Tomas") String owner//
 ) {
  return "Filtering... " + color + productionYear + owner;
 }
}


然后你可以调用这些方法。


CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .invoke(instance);


或者将任何默认值设置为其他值。


CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .withColor(Color.YELLOW)//
  .invoke(instance);

其它参考18


不,但我们有函数重载的替代方案。


没有参数传递时调用


void operation(){

int a = 0;
int b = 0;

} 


在传递a参数时调用


void operation(int a){

int b = 0;
//code

} 


参数b传递时调用


void operation(int a , int b){
//code
}