Paramètres facultatifs Java

1. Utiliser la surcharge de méthode pour avoir des paramètres facultatifs en Java
2. Utilisez l’objet conteneur Optional pour avoir des paramètres facultatifs en Java
3. Utilisez Build Pattern pour avoir des paramètres facultatifs en Java
4. Utilisez Varargs pour avoir des paramètres facultatifs en Java

En classe Java, lorsque nous concevons une méthode ou une fonction, certains arguments peuvent être optionnels pour son exécution. Il n’y a pas de paramètres facultatifs en Java, mais nous pouvons simuler des paramètres facultatifs à l’aide des techniques suivantes décrites dans cet article.

Utiliser la surcharge de méthode pour avoir des paramètres facultatifs en Java

Si une classe a plusieurs méthodes qui ont le même nom mais prennent des paramètres différents, on parle de surcharge de méthode. Ici nous avons une classe, Multiply, qui a deux méthodes avec le même nom mul. Les arguments passés aux méthodes sont différents, l’un prend deux arguments de type int tandis que l’autre en prend trois.

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

Production:

22
44

Utilisez l’objet conteneur Optional pour avoir des paramètres facultatifs en Java

En Java, Optional est un objet conteneur qui peut ou non contenir une valeur non nulle. Si une valeur est présente, alors la méthode isPresent() renverra true, et la méthode get() renverra la valeur.

Dans le cas où nous attendons des valeurs nulles, nous pouvons utiliser la méthode ofNullable() de cette classe. Il renvoie un objet Optional vide et ne lève pas d’exception. Ici, la variable lastName est passée à null pour l’objet de classe Student, nous avons donc créé un objet Optional qui peut contenir une valeur null.

La méthode isPresent() vérifie si la valeur est présente ; sinon, la chaîne par défaut lui est attribuée, comme indiqué dans le code ci-dessous.

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

Production

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

Utilisez Build Pattern pour avoir des paramètres facultatifs en Java

Le but du Build Pattern est de séparer la construction complexe de l’objet de sa représentation. La logique et les valeurs de configuration par défaut nécessaires à la création d’un objet sont enfermées dans la classe builder.

Ici, dans le code, nous utilisons une classe supplémentaire, UserBuilder, qui contient toutes les propriétés nécessaires et une combinaison de paramètres facultatifs pour construire un objet User sans perdre son immutabilité. Dans la classe User, il n’y a que des getters et pas de setters pour préserver l’immutabilité.

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

Dans la classe TestUser, nous utilisons le UserBuilder pour créer l’objet de classe User. Pour l’objet user1, nous passons tous les attributs, alors que pour l’objet user2, nous ne passons pas les arguments age et email. Ainsi, il prend des valeurs par défaut pour les paramètres facultatifs. La méthode build() construit l’objet User et le renvoie.

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

Production

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

Utilisez Varargs pour avoir des paramètres facultatifs en Java

En Java, Varargs (arguments de longueur variable) permet à la méthode d’accepter zéro ou plusieurs arguments. L’utilisation de cette approche particulière n’est pas recommandée car elle crée des problèmes de maintenance.

Ici dans le code ci-dessous, nous avons la classe VarargsExample qui a une méthode display(). Cette méthode prend un nombre arbitraire de paramètres de type String. Quelques règles à garder à l’esprit lors de l’utilisation de varargs sont que chaque méthode ne peut avoir qu’un seul paramètre varargs, et ce doit être le dernier paramètre.

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

Production

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