Optionale Java-Parameter

1. Verwenden Sie Methodenüberladung, um optionale Parameter in Java zu haben
2. Verwenden Sie das Container-Objekt Optional, um optionale Parameter in Java zu haben
3. Verwenden Sie Build Pattern, um optionale Parameter in Java zu haben
4. Verwenden Sie Varargs, um optionale Parameter in Java zu haben

Wenn wir in der Java-Klasse eine Methode oder Funktion entwerfen, können einige Argumente für deren Ausführung optional sein. In Java gibt es keine optionalen Parameter, aber wir können optionale Parameter simulieren, indem wir die folgenden Techniken verwenden, die in diesem Artikel beschrieben werden.

Verwenden Sie Methodenüberladung, um optionale Parameter in Java zu haben

Wenn eine Klasse mehrere Methoden hat, die denselben Namen haben, aber unterschiedliche Parameter annehmen, wird sie als Methodenüberladung bezeichnet. Hier haben wir eine Klasse Multiply, die zwei Methoden mit dem gleichen Namen mul hat. Die an die Methoden übergebenen Argumente sind unterschiedlich. Eine benötigt zwei Argumente vom Typ int, die andere drei.

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

Ausgabe:

22
44

Verwenden Sie das Container-Objekt Optional, um optionale Parameter in Java zu haben

In Java ist Optional ein Containerobjekt, das einen Wert ungleich Null enthalten kann oder nicht. Wenn ein Wert vorhanden ist, liefert die Methode isPresent() true und die Methode get() den Wert zurück.

Falls wir Nullwerte erwarten, können wir die Methode ofNullable() dieser Klasse verwenden. Es gibt ein leeres Optional-Objekt zurück und löst keine Ausnahme aus. Hier wird die Variable lastName für das Klassenobjekt Student null übergeben, also haben wir ein Optional-Objekt erstellt, das einen Null-Wert enthalten kann.

Die Methode isPresent() prüft, ob der Wert vorhanden ist; andernfalls wird ihm die StandardZeichenkette zugewiesen, wie im folgenden Code gezeigt.

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

Ausgabe

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

Verwenden Sie Build Pattern, um optionale Parameter in Java zu haben

Der Zweck des Build Pattern besteht darin, die komplexe Objektkonstruktion von ihrer Repräsentation zu trennen. Die zum Erstellen eines Objekts erforderlichen Logik- und Standardkonfigurationswerte sind in der Klasse builder enthalten.

Hier im Code verwenden wir eine zusätzliche Klasse, UserBuilder, die alle notwendigen Eigenschaften und eine Kombination optionaler Parameter umschließt, um ein User-Objekt zu erstellen, ohne die Unveränderlichkeit zu verlieren. In der Klasse User gibt es nur Getter und keine Setter, um die Unveränderlichkeit zu bewahren.

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

In der Klasse TestUser verwenden wir den UserBuilder, um das Klassenobjekt User zu erstellen. Für das Objekt user1 übergeben wir alle Attribute, während wir für das Objekt user2 die Argumente age und email nicht übergeben. Daher nimmt es Standardwerte für optionale Parameter. Die Methode build() konstruiert das Objekt User und gibt es zurück.

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

Ausgabe

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

Verwenden Sie Varargs, um optionale Parameter in Java zu haben

In Java erlaubt Varargs (Argumente variabler Länge) der Methode, null oder mehrere Argumente zu akzeptieren. Die Verwendung dieses speziellen Ansatzes wird nicht empfohlen, da er zu Wartungsproblemen führt.

Hier im Code unten haben wir die Klasse VarargsExample, die eine Methode display() hat. Diese Methode benötigt eine beliebige Anzahl von Parametern vom Typ String. Einige Regeln, die Sie bei der Verwendung von varargs beachten sollten, sind, dass jede Methode nur einen varargs-Parameter haben kann und dieser der letzte Parameter sein muss.

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

Ausgabe

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