constructor/método de Java con parámetros opcionales?

Question

Duplicar posible:
Java optional parameters

sé que en PHP si desea llamar a una función con menos parámetros declara la función como:

function foo(int param1, int param2 = "2"); 

y ahora Puedo llamar al foo(2) y param2 a 2.

Intenté hacer esto en un constructor de Java, pero parece que no es posible. ¿Hay alguna manera de hacerlo o solo tengo que declarar dos constructores?

Gracias!

Answer 1

Java no admite parámetros predeterminados. Necesitarás tener dos constructores para hacer lo que quieras.

Una alternativa si hay muchos valores posibles con los valores predeterminados es usar el patrón del generador, mediante el cual se utiliza un objeto auxiliar con los ajustadores.

p. Ej.

public class Foo { 
    private final String param1; 
    private final String param2; 

    private Foo(Builder builder) { 
     this.param1 = builder.param1; 
     this.param2 = builder.param2; 
    } 
    public static class Builder { 
     private String param1 = "defaultForParam1"; 
     private String param2 = "defaultForParam2"; 

     public Builder param1(String param1) { 
     this.param1 = param1; 
     return this; 
     } 
     public Builder param2(String param1) { 
     this.param2 = param2; 
     return this; 
     } 
     public Foo build() { 
     return new Foo(this); 
     } 
    } 
    } 

que le permite decir:

Foo myFoo = new Foo.Builder().param1("myvalue").build(); 

que tendrá un valor predeterminado para param2.

Answer 2

Java no tiene el concepto de parámetros opcionales con valores predeterminados ni en constructores ni en métodos. Básicamente estás atrapado en la sobrecarga. Sin embargo, se encadenan constructores fácilmente, por lo que no es necesario repetir el código:

public Foo(int param1, int param2) 
{ 
    this.param1 = param1; 
    this.param2 = param2; 
} 

public Foo(int param1) 
{ 
    this(param1, 2); 
} 

Answer 3

¿Por qué quieres hacer eso?

Sin embargo, Usted puede hacer esto:

public void foo(int param1) 
{ 
    int param2 = 2; 
    // rest of code 
} 

o:

public void foo(int param1, int param2) 
{ 
    // rest of code 
} 

public void foo(int param1) 
{ 
    foo(param1, 2); 
} 

Answer 4

No se puede tener argumentos opcionales que por defecto a un cierto valor en Java. Lo más cercano a lo que está hablando es java varargs mediante el cual puede pasar un número arbitrario de argumentos (del mismo tipo) a un método.

Answer 5

Puede simularlo con varargs, sin embargo, debe comprobarlo para ver demasiados argumentos.

public void foo(int param1, int ... param2) 
{ 
    int param2_ 
    if(param2.length == 0) 
     param2_ = 2 
    else if(para2.length == 1) 
     param2_ = param2[0] 
    else 
     throw new TooManyArgumentsException(); // user provided too many arguments, 

    // rest of the code 
} 

Sin embargo, este enfoque no es una buena manera de hacerlo, por lo tanto, es mejor utilizar la sobrecarga.

Answer 6

Puede utilizar varargs para los parámetros opcionales:

public class Booyah { 
    public static void main(String[] args) { 
     woohoo(1); 
     woohoo(2, 3); 
    } 
    static void woohoo(int required, Integer... optional) { 
     Integer lala; 
     if (optional.length == 1) { 
      lala = optional[0]; 
     } else { 
      lala = 2; 
     } 
     System.out.println(required + lala); 
    } 
} 

También es importante tener en cuenta el uso de Integer sobre int. Integer es a wrapper around the primitive int, lo que permite hacer comparaciones con null según sea necesario.