Parámetros opcionales de Java

1. Utilice la sobrecarga de métodos para tener parámetros opcionales en Java
2. Utilice el objeto contenedor Optional para tener parámetros opcionales en Java
3. Utilice Build Pattern para tener parámetros opcionales en Java
4. Utilice Varargs para tener parámetros opcionales en Java

En la clase Java, cuando diseñamos un método o función, algunos argumentos pueden ser opcionales para su ejecución. No hay parámetros opcionales en Java, pero podemos simular parámetros opcionales usando las siguientes técnicas discutidas en este artículo.

Utilice la sobrecarga de métodos para tener parámetros opcionales en Java

Si una clase tiene varios métodos que tienen el mismo nombre pero toman diferentes parámetros, se llama método Overloading. Aquí tenemos una clase, Multiplicar, que tiene dos métodos con el mismo nombre mul. Los argumentos pasados ​​a los métodos son diferentes, uno toma dos argumentos de tipo int mientras que el otro toma tres.

class Multiply {
  static int mul(int a, int b) {
    return a * b;
  }
  static int mul(int a, int b, int c) {
    return a * b * c;
  }
}
class TestOverloading {
  public static void main(String[] args) {
    System.out.println(Multiply.mul(2, 11));
    System.out.println(Multiply.mul(2, 2, 11));
  }
}

Producción :

22
44

Utilice el objeto contenedor Optional para tener parámetros opcionales en Java

En Java, Optional es un objeto contenedor que puede contener o no un valor no nulo. Si hay un valor presente, entonces el método isPresent() devolverá verdadero y el método get() devolverá el valor.

En caso de que esperemos algunos valores nulos, podemos usar el método ofNullable() de esta clase. Devuelve un objeto Optional vacío y no lanza una excepción. Aquí la variable lastName se pasa nula para el objeto de clase Student, por lo que creamos un objeto Optional que puede contener un valor nulo.

El método isPresent() comprueba si el valor está presente; de lo contrario, se le asigna la cadena predeterminada, como se muestra en el código siguiente.

import java.util.Optional;

public class Main {
  public static void main(String args[]) {
    Student("John", null, 25);
  }
  private static void Student(String name, String lastName, int age) {
    Optional<String> ln = Optional.ofNullable(lastName);
    String a = ln.isPresent() ? ln.get() : "Not Given";
    System.out.println("name : " + name + ", lastname : " + a + ", age : " + age);
  }
}

Producción

name : John, lastname : Not Given, age : 25

Utilice Build Pattern para tener parámetros opcionales en Java

El propósito del Build Pattern es separar la construcción del objeto complejo de su representación. Los valores de configuración lógicos y predeterminados necesarios para crear un objeto se incluyen en la clase builder.

Aquí en el código, usamos una clase adicional, UserBuilder, que incluye todas las propiedades necesarias y una combinación de parámetros opcionales para construir un objeto User sin perder la inmutabilidad. En la clase User, solo hay captadores y no definidores para preservar la inmutabilidad.

public class User {
  private final String firstName; // required
  private final String lastName; // required
  private final int age; // optional
  private final String email; // optional

  private User(UserBuilder builder) {
    this.firstName = builder.firstName;
    this.lastName = builder.lastName;
    this.age = builder.age;
    this.email = builder.email;
  }

  public String getFirstName() {
    return firstName;
  }
  public String getLastName() {
    return lastName;
  }
  public int getAge() {
    return age;
  }
  public String getEmail() {
    return email;
  }

  @Override
  public String toString() {
    return "User: " + this.firstName + ", " + this.lastName + ", " + this.age + ", " + this.email;
  }

  public static class UserBuilder {
    private final String firstName;
    private final String lastName;
    private int age;
    private String email;

    public UserBuilder(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
    }
    public UserBuilder age(int age) {
      this.age = age;
      return this;
    }
    public UserBuilder email(String email) {
      this.email = email;
      return this;
    }
    public User build() {
      User user = new User(this);
      return user;
    }
  }
}

En la clase TestUser, utilizamos el UserBuilder para crear el objeto de clase User. Para el objeto user1, pasamos todos los atributos, mientras que para el objeto user2, no pasamos los argumentos age y email. Por lo tanto, toma valores predeterminados para parámetros opcionales. El método build() construye el objeto User y lo devuelve.

public class TestUser {
  public static void main(String args[]) {
    User user1 = new User.UserBuilder("John", "Doe").age(24).email("john.doe@dex.com").build();

    System.out.println(user1);
    User user2 = new User.UserBuilder("Jack", "Luther").build();

    System.out.println(user2);
  }
}

Producción

User: John, Doe, 24, john.doe@dex.com
User: Jack, Luther, 0, null

Utilice Varargs para tener parámetros opcionales en Java

En Java, Varargs (argumentos de longitud variable) permite que el método acepte cero o varios argumentos. No se recomienda el uso de este enfoque en particular, ya que crea problemas de mantenimiento.

Aquí, en el código siguiente, tenemos la clase VarargsExample que tiene un método display(). Este método toma un número arbitrario de parámetros del tipo String. Algunas reglas a tener en cuenta al usar varargs es que cada método puede tener solo un parámetro varargs, y debe ser el último parámetro.

public class VarArgsCheck {
  public static void main(String args[]) {
    VarargsExample.display();
    VarargsExample.display("here", "are", "the", "varargs", "to", "check");
  }
}
class VarargsExample {
  static void display(String... values) {
    String arr[] = values;
    System.out.println("display method invoked ");
    System.out.println("Value length " + arr.length);
  }
}

Producción

display method invoked 
Value length 0
display method invoked 
Value length 6