Parâmetros opcionais Java

1. Use a sobrecarga de método para ter parâmetros opcionais em Java
2. Use o objeto Container Optional para ter parâmetros opcionais em Java
3. Use Build Pattern para ter parâmetros opcionais em Java
4. Use Varargs para ter parâmetros opcionais em Java

Na classe Java, quando projetamos um método ou função, alguns argumentos podem ser opcionais para sua execução. Não há parâmetros opcionais em Java, mas podemos simular parâmetros opcionais usando as seguintes técnicas discutidas neste artigo.

Use a sobrecarga de método para ter parâmetros opcionais em Java

Se uma classe tiver vários métodos com o mesmo nome, mas com parâmetros diferentes, ela é chamada de método Overloading. Aqui temos uma classe, Multiply, que possui dois métodos com o mesmo nome mul. Os argumentos passados ​​para os métodos são diferentes, um leva dois argumentos do tipo int, enquanto o outro leva três.

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

Resultado:

22
44

Use o objeto Container Optional para ter parâmetros opcionais em Java

Em Java, Optional é um objeto de contêiner que pode ou não conter um valor não nulo. Se um valor estiver presente, o método isPresent() retornará verdadeiro e o método get() retornará o valor.

Caso esperemos alguns valores nulos, podemos usar o método ofNullable() desta classe. Ele retorna um objeto Optional vazio e não lança uma exceção. Aqui, a variável lastName é passada como nula para o objeto de classe Student, então criamos um objeto Optional que pode conter um valor nulo.

O método isPresent() verifica se o valor está presente; caso contrário, a string padrão é atribuída a ele, conforme mostrado no código a seguir.

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

Resultado

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

Use Build Pattern para ter parâmetros opcionais em Java

O objetivo do Build Pattern é separar a construção de objetos complexos de sua representação. Os valores lógicos e de configuração padrão necessários para criar um objeto são incluídos na classe builder.

Aqui no código, usamos uma classe adicional, UserBuilder, que inclui todas as propriedades necessárias e uma combinação de parâmetros opcionais para construir um objeto User sem perder a imutabilidade. Na classe User, existem apenas getters e não setters para preservar a imutabilidade.

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

Na classe TestUser, utilizamos o UserBuilder para criar o objeto de classe User. Para o objeto user1, passamos todos os atributos, enquanto para o objeto user2, não passamos os argumentos age e email. Portanto, ele usa valores padrão para parâmetros opcionais. O método build() constrói o objeto User e o retorna.

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

Resultado

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

Use Varargs para ter parâmetros opcionais em Java

Em Java, Varargs (argumentos de comprimento variável) permite que o método aceite zero ou vários argumentos. O uso desta abordagem específica não é recomendado, pois cria problemas de manutenção.

Aqui no código abaixo, temos a classe VarargsExample que possui um método display(). Este método leva um número arbitrário de parâmetros do tipo String. Algumas regras para se manter em mente ao usar varargs é que cada método pode ter apenas um parâmetro varargs e deve ser o ú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);
  }
}

Resultado

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