Java Default Parameters Using Method Overloading

Overview: In this tutorial, we are going to learn how to pass method arguments default parameters in java. However, in some of the other languages like C++, Scala is supporting default parameter(s) in method arguments, where by default Java language will not support, but Java application development company provides some ways to do the same.

Example:
Let’s create a Java Class Tea, with some properties in it like name, milk, sugar, teaPowder, etc…


public class Tea

{
public static final int DEFAULT_TEA_POWDER = 1;
public static final boolean DEFAULT_HERBS = false;
public static final int DEFAULT_MILK = 1;
public static final int DEFAULT_SUGAR = 1;

private String name;
private int milk;
private boolean herbs;
private int sugar;
private int teaPowder;
// setters and getters
}

Here, the name is a required field, and other properties are optional fields.

For each parameter, we will specify default parameters at class level, constants. (Like DEFAULT_TEA_POWDER, DEFAULT_HERBS, etc.)

First, we will create a constructor will all the fields, like below:

public Tea(String name, int milk, boolean herbs, int sugar, int teaPowder)

{
super();
this.name = name;
this.milk = milk;
this.herbs = herbs;
this.sugar = sugar;
this.teaPowder = teaPowder;
}

As teaPowder is optional, and we have a default parameter, so we need to create a constructor without teaPowder.

public Tea(String name, int milk, boolean herbs, int sugar)

{
this(name,milk,herbs,sugar,DEFAULT_TEA_POWDER);
}

Here, teaPowder argument is not present, so we will use DEFAULT_TEA_POWDER value for teaPowder field.

Next, sugar is also an optional parameter, and we have the default parameter for its value, create a constructor without sugar property,

public Tea(String name, int milk, boolean herbs)

{
this(name,milk,herbs,DEFAULT_SUGAR);
}

We will invoke previously created constructor, with DEFAULT_SUGAR value for sugar field.

Similarly, we can create other constructors, and one level up constructor, by passing default values.

public Tea(String name, int milk)

{
this(name,milk,DEFAULT_HERBS);
}
public Tea(String name) {
this(name,DEFAULT_MILK);
}

So, if we observe, we are constructor overloading to move the default parameters to java methods.

Suggested Approach: first, create a constructor will all the required/mandatory fields, and create constructor(s), by adding one more field to previous constructor until you reach a constructor will all the fields.

And the constructor invoking will be reverse of the constructor creation.

Now, let’s create a junit test class, for the above class.

@Test
public void whenTeaWithOnlyName_thenCreateDefaultTea()
{
Tea tea = new Tea("Green Tea");
assertEquals(tea.getMilk(), Tea.DEFAULT_MILK);
assertEquals(tea.getSugar(), Tea.DEFAULT_SUGAR);
assertEquals(tea.isHerbs(), Tea.DEFAULT_HERBS);
assertEquals(tea.getTeaPowder(), Tea.DEFAULT_TEA_POWDER);
}

Create a constructor with all mandatory fields, like name in our case.

And we will check for field values with corresponding default values.

Java provides some alternative to the above approach:

  1. We can pass null values for optional parameters as method arguments.
  2. Use Optional argument type (introduced in Java 8).
  3. Use Builder Design pattern

Conclusion: In the current article, we learned, using method overloading technique, to simulate the default parameter(s) to a method, as by default JVM will not allow to do it.

You might like

We use cookies in order to give you the best possible experience on our website. By continuing to use this site, you agree to our use of cookies.
Accept