Overload or Optional Parameters

Question

When I have a function that might, or might not receive a certain parameter, is it better to overload the function, or to add optional args?

If each one has it's ups and downs - when would I use each?

Answer 1

If the language supports them properly (e.g. type-safety, if applicable), I would prefer optional arguments for the following reasons:

• They convey your intent better so noone suspects that your function overload will do something different (which it probably shouldn't anyway).
• Less code to maintain, even if the function overload only delegates to the more comprehensive one. If you want to rename the function later, you have at least 3 places to do it (two definitions + one call).
• The compiler (if any) might generate smaller binaries.
• Optional arguments scale better, at least in some languages. What if you want to have 3 optional arguments with the ability to mix and match? For full flexibility, you'd need 6 overloads to do that.
• If it's an object method, multiple overloads will greatly hinder the implementation of overrides in subclasses.

Answer 2

Assuming a constructor kind of situation: I often choose a fluent builder pattern to prevent situations with many options.

Eg.Ordering.natural().onResultOf(function).reverse().compound(Ordering.natural().onResultOf(function2)) is an example of calling a fluent builder interface implemented in Guava.

Of course you now need a separate object to hold the state of your builder, but you reduce overall complexity by separating behavior of constructing from behavior of the constructed.