Default parameters for Java methods

Java lacks direct support for default parameter values as seen in some other programming languages. However, there are several techniques and patterns you can utilize to achieve similar functionality. In this tutorial, we’ll explore five different approaches to emulate default parameter values in Java.

1. Method Overloading

Method overloading involves creating multiple versions of a method with different parameter lists. This allows invoking the method with different sets of parameters:

public void doSomething(int param1) {
    // Method implementation with one parameter
}

public void doSomething(int param1, int param2) {
    // Method implementation with two parameters
}

Drawback: Maintenance becomes cumbersome as you add more overloaded methods, making it harder to manage and potentially cluttering the codebase.

2. Using Varargs

Varargs allow methods to accept a variable number of arguments. You can then extract specific arguments or use default values for missing parameters:

public void doSomething(int... params) {
    int param1 = (params.length >= 1) ? params[0] : DEFAULT_VALUE_1;
    int param2 = (params.length >= 2) ? params[1] : DEFAULT_VALUE_2;
    // Method implementation using param1 and param2
}

Limitation: Varargs don’t enforce a specific number or type of arguments, leading to potential runtime errors if used incorrectly.

3. Using Builder Pattern

Implement a builder pattern where methods in the builder class set parameters, providing default values:

public class SomethingBuilder {
    private int param1 = DEFAULT_VALUE_1;
    private int param2 = DEFAULT_VALUE_2;

    public SomethingBuilder withParam1(int param1) {
        this.param1 = param1;
        return this;
    }

    public SomethingBuilder withParam2(int param2) {
        this.param2 = param2;
        return this;
    }

    public void build() {
        // Method implementation using param1 and param2
    }
}

Drawback: The creation and usage of a builder class might be overkill for simpler scenarios, causing unnecessary overhead.

4. Utilizing Optional

Java 8 introduced the Optional class. While not explicitly for default values, it allows handling optional parameters:

public void doSomething(Optional<Integer> param1, Optional<Integer> param2) {
    int val1 = param1.orElse(DEFAULT_VALUE_1);
    int val2 = param2.orElse(DEFAULT_VALUE_2);
    // Method implementation using val1 and val2
}

Limitation: The Optional class wasn’t designed explicitly for emulating default parameters, which can result in boilerplate code when handling optional values.

Optional is a common topic in Java interviews: check this list of Modern Java interview questions (2023)

5. Enums

You can use Enums to represent a set of possible values with default values. For example, consider the following code:

enum Operation {
  ADD {
    public int apply(int a, int b) {
      return a + b;
    }
  },
  SUBTRACT {
    public int apply(int a, int b) {
      return a - b;
    }
  },
  MULTIPLY {
    public int apply(int a, int b) {
      return a * b;
    }
  },
  DIVIDE {
    public int apply(int a, int b) {
      return a / b;
    }
  }
}

class Calculator {
  public int calculate(int a, int b, Operation operation) {
    return operation.apply(a, b);
  }
}

In this example, the Operation enum represents a set of possible operations with default values. The calculate() method takes the operation as an argument, allowing the user to specify the desired operation.

Drawback: Enums are limited to a finite set of predefined values, which may not be suitable for all situations where dynamic or context-dependent default values are needed.

Conclusion

These approaches offer different ways to emulate default parameter values in Java, providing flexibility in method invocation. Consider each approach’s advantages and limitations when designing your methods to ensure your code remains readable and maintainable.

Found the article helpful? if so please follow us on Socials