How do I use optional parameters in Java?

java

optional-parameters

varargs

clean-code

byNikita Barsukov·Aug 20, 2024

To create optional parameters in Java, utilize method overloading or Builder pattern. With overloading, you define methods with the same name but different arrangements of parameters—here's a sample:

class Greeter {
    void greet(String name) {
        // Is it a secret guest? Let's find out!
        System.out.println("Hello, " + (name != null ? name : "Guest... or is it Batman?"));
    }
}

// Usage
new Greeter().greet(null); // Hello, Guest... or is it Batman?
new Greeter().greet("Jon"); // Hello, Jon

When dealing with a larger number of optional parameters, the Builder pattern provides a readable and efficient solution:

class Greeter {
    private String name = "Guest";

    Greeter setName(String name) {
        this.name = name;
        return this;
    }

    void greet() {
        System.out.println("Hello, " + name + "... unless you're Batman in disguise!");
    }
}

// Usage
new Greeter().setName("Sarah").greet(); // Hello, Sarah... unless you're Batman in disguise!

Juggling parameters: Using Varargs

For a variable number of parameters, Java offers varargs. It allows passing any number of arguments, while making sure there's no ambiguity when overloading.

class Logger {
    void log(String... messages) {
        for (String message : messages) {
            // The code never lies, or does it?
            System.out.println(message);
        }
    }
}

// Usage
new Logger().log("Debug", "Info"); // Logs two mysterious messages

Guarding against null: Optional Class

Every now and then, we encounter optional parameters that may be null. Fear not, Java 8's Optional class is here to rescue from NullPointerException!

class Invitation {
    void sendInvite(String email, Optional<String> message) {
        System.out.println("Sending invite to " + email);
        message.ifPresent(msg -> System.out.println("Message: " + msg + " -- if you dare!"));
    }
}

// Usage
new Invitation().sendInvite("[email protected]", Optional.of("Join us... in the Batcave!"));

Meet the toolbox: Using Maps

When dealing with larger sizes of optional parameters, Maps come to the rescue! This technique keeps your code readable and maintainable.

class Configuration {
    void setConfig(Map<String, Object> options) {
        // Set configuration, but remember - with great power, comes great responsibility!
    }
}

// Usage
new Configuration().setConfig(Map.of("color", "blue", "size", "large")); // Colors set to Batmobile standard

A Blend of Techniques: Custom solutions

Incorporate a mix of overloading, varargs, and maps to implement optimal solutions. Direct calls from overloaded methods to private methods with default values to maintain consistency.

class CustomBuilder {
    private final Map<String, Object> options = new HashMap<>();

    CustomBuilder withOption(String key, Object value) {
        options.put(key, value);
        return this;
    }
    // More builder methods...
}

// Usage
new CustomBuilder().withOption("theme", "dark").withOption("layout", "modern"); // Building the Batcave, maybe?

Enhance your arsenal: Additional strategies

Clean public API with private helper methods

Private helper methods with default values help avoid repetitive code and maintain a neat public API.

class MessageSender {
    void sendMessage(String message) {
        sendMessage(message, "text/plain", null);
    }

    void sendMessage(String message, String contentType) {
        sendMessage(message, contentType, null);
    }

    private void sendMessage(String message, String contentType, String encoding) {
        // Displaying secret message, shhh!
    }
}

// Usage
new MessageSender().sendMessage("Hello, World!", "text/html"); // Will also print secret Bat signal

Default method parameters using functional programming

Although native support for optional method parameters is absent in Java, you can simulate it with functional interfaces and lambdas.

@FunctionalInterface
interface ConfigurationSetter {
    void applyConfig(Configuration config);
}

class AdvancedConfiguration {
    void setConfig(ConfigurationSetter... setters) {
        Configuration config = new Configuration();
        for (ConfigurationSetter setter : setters) {
            setter.applyConfig(config);
        }
        // Applying Bat-tech configuration here
    }
}

// Usage
new AdvancedConfiguration().setConfig(
    c -> c.setParameter("timeout", 5000),
    c -> c.enableFeature("logging", true)
);

Clean code tips

To maintain a clean code base, focus on creating overloaded methods with well-thought-out parameter order. Adhere to the single responsibility principle to prevent method monoliths.