Parámetros opcionales de Java

Contamos con el arreglo a esta problema, o por lo menos eso pensamos. Si tienes preguntas puedes escribirlo en el apartado de comentarios y con gusto te responderemos

Solución:

Hay varias formas de simular parámetros opcionales en Java:

1. 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 tiene dos parámetros opcionales del mismo tipo y cualquiera de ellos se puede omitir.

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) Los tipos de parámetros opcionales 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, pierde static comprobación de tipos. Además, si cada parámetro tiene un significado diferente, necesita alguna forma de distinguirlos.

3. Nulos. Para abordar las limitaciones de los enfoques anteriores, puede permitir null valores y luego analice cada parámetro en un cuerpo de método:

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

   Ahora se deben proporcionar todos los valores de los argumentos, pero los predeterminados pueden ser null.

4. Clase opcional. Este enfoque es similar a los valores nulos, pero utiliza la clase opcional de Java 8 para los parámetros que tienen un valor predeterminado:

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

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

   Actualización: Java 8 incluye la clase java.util.Optional listo para usar, por lo que no hay necesidad de usar guayaba por este motivo en particular en Java 8. Sin embargo, el nombre del método es un poco diferente.

5. Patrón de constructor. El patrón de constructor se usa para constructores y se implementa mediante la introducción de una clase de constructor independiente:

    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 normalmente se utilizan la mayoría de los valores predeterminados, puede pasar argumentos de método como un mapa de sus nombres/valores:

   void foo(Map 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.of(
       "a", "a",
       "b", 2, 
       "d", "value")); 
   

   En Java 9, este enfoque se volvió más fácil:

       @SuppressWarnings("unchecked")
       static  T getParm(Map map, String key, T defaultValue)
       
           return (map.containsKey(key)) ? (T) map.get(key) : defaultValue;
       
   
       void foo(Map parameters) 
           String a = getParm(parameters, "a", "");
           int b = getParm(parameters, "b", 0);
           // d = ...
       
   
       foo(Map.of("a","a",  "b",2,  "d","value"));
   

Tenga en cuenta que puede combinar cualquiera de estos enfoques para lograr un resultado deseable.

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

private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) 
    ...


public void doSomething() 
    doSomething(defaultOptionalFlagValue);

Hay parámetros opcionales con Java 5.0. Solo declara tu función así:

public void doSomething(boolean... optionalFlag) 
    //default to "false"
    //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;

podrías llamar con doSomething(); o doSomething(true); ahora.

Nos encantaría que puedieras mostrar este artículo si si solucionó tu problema.

---

---

Utiliza Nuestro Buscador