Is NULL arguments a bad practice?

Question

Is it a bad practice to pass NULL argument to methods or in other words should we have method definitions which allow NULL argument as valid argument.

Suppose i want two method 1. to retrieve list of all of companies 2. to retrieve list of companies based upon filter.

We can either have two methods like as below

    List<Company> getAllCompaniesList();
    List<Company> getCompaniesList(Company companyFilter);

or we can have one single method

    List<Company> getCompaniesList(Company companyFilter);

here in second case, if argument is NULL then method return list of all of companies.

Beside question of good practice practically i see one more issue with later approach which is explained below.

I am implementing Spring AOP, in which i want to have some checks on arguments like 1. Is argument NULL ? 2. is size of collection 0?

There are some scenarios where we can not have null argument at all like for method

    void addBranches(int companyId, List<Branch>);

This check can be performed very well by using Spring AOP by defining method like following

@Before(argNames="args", value="execution(* *)")
void beforeCall(JoinPoint joinPoint ,Object[] args )
{ 
           foreach(Object obj in args)
           {
                 if(obj == NULL)
                 {
                     throw new Exception("Argument NULL");
                 } 
           }   
}

But problem i am facing is since i have defined some of methods which should accept NULL argument for multiple functionality of one single method as mentioned above for method List getCompaniesList(Company companyFilter); So i can not apply AOP uniformly for all of methods and neither some expression for methods name match will be useful here.

Please let me know if more information is required or problem is not descriptive enough.

Thanks for reading my problem and giving thought upon it.

I believe the dilemma starts with: "accept NULL argument for multiple functionality of one single method", each method should do just one think. In your example I Will prefer send a list of filters, and an empty list should have the same effect that sending null in your method. — Enrique Palacio
– Enrique Palacio, Commented Mar 3, 2020 at 16:02

Bozho · Accepted Answer · 2010-12-26 20:07:04Z

22

It's fine, in cases when there are too many overloaded methods. So instead of having all combinations of parameters, you allow some of them to be null. But if you do so, document this explicitly with

@param foo foo description. Can be null

In your case I'd have the two methods, where the first one invokes the second with a null argument. It makes the API more usable.

There is no strict line where to stop overloading and where to start relying on nullable parameters. It's a matter of preference. But note that thus your method with the most params will allow some of them to be nullable, so document this as well.

Also note that a preferred way to cope with multiple constructor parameters is via a Builder. So instead of:

public Foo(String bar, String baz, int fooo, double barr, String asd);

where each of the arguments is optional, you can have:

Foo foo = new FooBuilder().setBar(bar).setFooo(fooo).build();

edited Dec 26, 2010 at 20:07

answered Dec 26, 2010 at 19:52

Bozho

599k147 gold badges1.1k silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

MasterJoe Over a year ago

But, then we have to create one method per parameter (unless we group some parameters into an object, eg. string username, string password = object user). It is useful & pretty, but isn't it too much code ? Also, henning77 says its not okay from a practical perspective due to all the NPEs it could cause.

vanshaj · Accepted Answer · 2021-08-07 11:44:20Z

22

I use a very simple rule:

Never allow null as an argument or return value on a public method.

I make use of Optional and Preconditions or AOP to enforce that rule. This decision already saved me tons of hours bugfixing after NPE's or strange behaviour.

edited Aug 7, 2021 at 11:44

vanshaj

5591 gold badge4 silver badges13 bronze badges

answered Jan 23, 2013 at 12:33

henning77

3,8442 gold badges28 silver badges32 bronze badges

4 Comments

Duke Over a year ago

Great links! As an experienced programmer just gaining more literacy in Java, this is very useful.

Stepan Over a year ago

setLocationRelativeTo(null); ... I wish Sun/Oracle knew it is a bad practice.

MasterJoe Over a year ago

But Bozho says its okay to allow null arguments sometimes. Would you agree ?

Bastian Voigt Over a year ago

Optional ist just another kind of NULL. If you're serious about this, you shouldn't use Optional either

Tim Barrass · Accepted Answer · 2010-12-26 19:36:22Z

8

It's common practice, but there are ways of making your code clearer - avoiding null checks in sometimes, or moving them elsewhere. Look up the null object pattern - it may well be exactly what you need: http://en.m.wikipedia.org/wiki/Null_Object_pattern?wasRedirected=true

answered Dec 26, 2010 at 19:36

Tim Barrass

4,9892 gold badges33 silver badges57 bronze badges

2 Comments

Maddy.Shik Over a year ago

Thanks, Can u please provide some good links for same if you already know?

Maddy.Shik Over a year ago

Null object pattern can be useful for some of scenarios like returning collection not in all cases like in case its single object i will return NULL.

Michael Lorton · Accepted Answer · 2010-12-26 20:08:20Z

4

The rule is: simple interface, complicated implementation.

Design decisions about your API should be made by considering how the client code is likely to use it. If you expect to see either

getAllCompaniesList(null);

or

if (companyFilter == null) {
    getAllCompaniesList();
} else {
    getAllCompaniesList(companyFilter);
}

then you're doing it wrong. If the likely use-case is that the client code will, at the time it is written, either have or not have a filter, you should supply two entry points; if that decision is likely not made until run-time, allow a null argument.

answered Dec 26, 2010 at 20:08

Michael Lorton

44.7k26 gold badges111 silver badges159 bronze badges

Comments

supercat · Accepted Answer · 2013-01-23 20:27:00Z

1

Another approach that may be workable may be to have a CompanyFilter interface with an companyIsIncluded(Company) method that accepts a Company and returns true or false to say whether any company should be included. Company could implement the interface so that companyIsIncluded method's behavior mirrored equals(), but one could easily have a singleton CompanyFilter.AllCompanies whose companyIsIncluded() method would always return true. Using that approach, there's no need to pass a null value--just pass a reference to the AllComapnies singleton.

answered Jan 23, 2013 at 20:27

supercat

82k9 gold badges178 silver badges226 bronze badges

Collectives™ on Stack Overflow

Is NULL arguments a bad practice?

5 Answers 5

1 Comment

4 Comments

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

4 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related