Parametri opzionali Java

1. Usa il metodo di sovraccarico per avere parametri opzionali in Java
2. Utilizzare l’oggetto contenitore Optional per avere parametri facoltativi in ​​Java
3. Usa Build Pattern per avere parametri opzionali in Java
4. Usa Varargs per avere parametri opzionali in Java

Nella classe Java, quando progettiamo un metodo o una funzione, alcuni argomenti possono essere facoltativi per la sua esecuzione. Non ci sono parametri facoltativi in ​​Java, ma possiamo simulare parametri facoltativi utilizzando le seguenti tecniche discusse in questo articolo.

Usa il metodo di sovraccarico per avere parametri opzionali in Java

Se una classe ha più metodi che hanno lo stesso nome ma accetta parametri diversi, si chiama metodo Overloading. Qui abbiamo una classe, Multiply, che ha due metodi con lo stesso nome mul. Gli argomenti passati ai metodi sono diversi, uno accetta due argomenti di tipo int mentre l’altro ne accetta tre.

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

Produzione:

22
44

Utilizzare l’oggetto contenitore Optional per avere parametri facoltativi in ​​Java

In Java, Optional è un oggetto contenitore che può contenere o meno un valore non nullo. Se è presente un valore, il metodo isPresent() restituirà true e il metodo get() restituirà il valore.

Nel caso in cui ci aspettiamo dei valori nulli, possiamo usare il metodo ofNullable() di questa classe. Restituisce un oggetto Optional vuoto e non genera un’eccezione. Qui la variabile lastName viene passata null per l’oggetto della classe Student, quindi abbiamo creato un oggetto Optional che può contenere un valore null.

Il metodo isPresent() verifica se il valore è presente; in caso contrario gli viene assegnata la stringa di default, come mostrato nel codice sottostante.

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

Produzione

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

Usa Build Pattern per avere parametri opzionali in Java

Lo scopo del Build Pattern è separare la costruzione dell’oggetto complesso dalla sua rappresentazione. La logica e i valori di configurazione di default necessari per creare un oggetto sono racchiusi nella classe builder.

Qui nel codice usiamo una classe aggiuntiva, UserBuilder, che racchiude tutte le proprietà necessarie e una combinazione di parametri opzionali per costruire un oggetto User senza perdere l’immutabilità. Nella classe Utente, ci sono solo getter e nessun setter per preservare 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;
    }
  }
}

Nella classe TestUser, utilizziamo l’UserBuilder per creare l’oggetto della classe User. Per l’oggetto user1 passiamo tutti gli attributi, mentre per l’oggetto user2 non passiamo gli argomenti age e email. Quindi prende i valori predefiniti per i parametri opzionali. Il metodo build() costruisce l’oggetto User e lo restituisce.

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

Produzione

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

Usa Varargs per avere parametri opzionali in Java

In Java, Varargs (argomenti a lunghezza variabile) consente al metodo di accettare zero o più argomenti. L’uso di questo particolare approccio non è consigliato in quanto crea problemi di manutenzione.

Qui nel codice seguente, abbiamo la classe VarargsExample che ha un metodo display(). Questo metodo accetta un numero arbitrario di parametri di tipo Stringa. Poche regole da tenere a mente durante l’utilizzo di varargs sono che ogni metodo può avere un solo parametro varargs, e deve essere l’ultimo parametro.

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

Produzione

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