method默认参数 - Java是否支持默认参数值?




java缺省 (13)

我遇到了一些具有以下结构的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是否支持这种语法? 有没有任何理由为什么这两个步骤的语法是可取的?


,但最简单的实现方法是:

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

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


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


不,但您可以使用Builder模式如此堆栈溢出答案中所述

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

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

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


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

对于构造函数,如果重载变得复杂, 请参阅“有效Java:编程语言指南”的第1项技巧(考虑静态工厂方法而不是构造函数)。 对于其他方法,重命名某些情况或使用参数对象可以提供帮助。 这是当你有足够的复杂性,差异化是困难的。 一个确定的情况是你必须使用参数顺序进行区分,而不仅仅是数字和类型。


可悲的是没有。


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

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";} { param1 = 10; param2 = "bar";}


尝试此解决方案:

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

    return score;
}

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

只需将@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);

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

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

有几种方法可以模拟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. 空值。 要解决先前方法的局限性,您可以允许空值,然后分析方法体中的每个参数:

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

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

  4. 可选课程。 此方法类似于空值,但对于具有默认值的参数使用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");
        }
        if (parameters.containsKey("b")) { 
            //... 
        }
        //...
    }
    
    foo(ImmutableMap.<String, Object>of(
        "a", "a",
        "b", 2, 
        "d", "value")); 
    

请注意,您可以将这些方法结合起来,以达到理想的效果。


有这么多问题或更好的问题,最终你会到达静态工厂模式......请参阅crypto API。 排序很难解释,但这样想:如果你有一个构造函数,默认或其他方式,将状态传播到花括号之外的唯一方法是使用布尔isValid; (以null作为默认值v失败的构造函数),或者抛出一个从现场用户获取它时从不提供信息的异常。

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

我认为我们在这里需要做的是解决null作为缺省值的问题,而不是针对某些事情。String one = new String(“”); 作为成员变量,然后在分配传递给构造函数的字符串之前检查null。

Java中完成的原始平流层计算机科学数量非常惊人。

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


这就是我所做的......它不像对你定义的参数有'可选参数'那样方便,但它完成了工作:

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为参数提供了一个“可选参数”要简洁一些,因为我们需要编写默认值等等。在这个例子中,我不需要担心任何这些。 是的,我已经为班上增加了另一种方法,但从长远来看,我认为更容易阅读。





method-overloading