340 votos

Parámetros opcionales de Java

¿Cómo puedo utilizar parámetros opcionales en Java? ¿Qué especificación admite parámetros opcionales?

851voto

Vitalii Fedorenko Puntos 17469

Hay varias formas para simular los parámetros opcionales en Java:

  1. La sobrecarga de métodos.

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

    Una de las limitaciones de este enfoque es que no funciona si usted tiene dos parámetros opcionales del mismo tipo y cualquiera de ellos puede ser omitido.

  2. Varargs.

    a) Todos los parámetros opcionales son del mismo tipo:

    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) Tipos de parámetros opcionales que pueden ser diferentes:

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

    El principal inconveniente de este enfoque es que si los parámetros opcionales son de diferentes tipos que pierden la comprobación de tipo estático. Además, si cada parámetro tiene un significado diferente que usted necesita una cierta manera de distinguirlos.

  3. Valores nulos. Para hacer frente a las limitaciones de los planteamientos anteriores se puede permitir valores nulo y, a continuación, analizar cada parámetro de un método de cuerpo:

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

    Ahora todos los argumentos valores deben ser suministrados, pero el defecto puede ser null.

  4. Clase opcional. Este enfoque es similar a los nulos, pero utiliza la guayaba clase Opcional de parámetros que tienen un valor por defecto:

    void foo(String a, Optional<Integer> bOpt) {
        Integer b = bOpt.isPresent() ? bOpt.get() : 0;
        //...
    }
    
    foo("a", Optional.of(2));
    foo("a", Optional.<Integer>absent());
    

    Opcional hace que un método de contrato explícito para una persona que llama, sin embargo, uno puede encontrar a dicha firma demasiado detallado.

  5. Generador de patrón. El generador de patrón se utiliza para los constructores y que es implementado por la introducción de un independiente Constructor de la clase:

     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. Mapas. Cuando el número de parámetros es demasiado grande y para la mayoría de ellos los valores predeterminados se utilizan generalmente, usted puede pasar argumentos de método como un mapa de sus nombres/valores:

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

Por favor, tenga en cuenta que usted puede combinar cualquiera de estos enfoques para lograr un resultado deseable.

237voto

laginimaineb Puntos 3049

varargs podría hacer eso (de una manera). Aparte de eso, todas las variables en la declaración del método deberán ser suministrados. Si desea que una variable sea opcional, se puede sobrecargar el método que utiliza una firma que no requiere el parámetro.

 private boolean defaultOptionalFlagValue = true;

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

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

80voto

theninjagreg Puntos 884

Puedes usar algo como esto:

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

El params variable es opcional. Se trata como una matriz de objetos anulable.

Extrañamente, no pude encontrar nada sobre esto en la documentación, pero funciona!

Esta es "nuevo" en Java 1.5 y más allá (no compatible con Java 1.4 o anterior).

Veo bhoot usuario mencionó esta muy por debajo.

50voto

bhoot Puntos 353

Hay parámetros opcionales con Java 5.0. Simplemente declarar su función como esta:

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

se puede llamar con doSomething () o doSomething (true) ahora.

31voto

Scott Stanchfield Puntos 15863

Por desgracia, Java no soporta parámetros por defecto de forma directa.

Sin embargo, he escrito un conjunto de JavaBean anotaciones, y uno de ellos de soporte por defecto de los parámetros como los siguientes:

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

La anotación procesador genera el método de sobrecargas para soportar adecuadamente este.

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

Ejemplo completo en http://code.google.com/p/javadude/wiki/AnnotationsDefaultParametersExample

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X