Is returning null bad design? [closed]

by

The rationale behind not returning null is that you do not have to check for it and hence your code does not need to follow a different path based on the return value. You might want to check out the Null Object Pattern which provides more information on this.

For example, if I were to define a method in Java that returned a Collection I would typically prefer to return an empty collection (i.e. Collections.emptyList()) rather than null as it means my client code is cleaner; e.g.

Collection<? extends Item> c = getItems(); // Will never return null.

for (Item item : c) { // Will not enter the loop if c is empty.
  // Process item.
}

… which is cleaner than:

Collection<? extends Item> c = getItems(); // Could potentially return null.

// Two possible code paths now so harder to test.
if (c != null) {
  for (Item item : c) {
    // Process item.
  }
}

More Related Contents:

  1. Method Overloading for null argument
  2. Why doesn’t Rust support trait object upcasting?
  3. Inheritance vs. Aggregation [closed]
  4. Constructors vs Factory Methods [closed]
  5. Why would I want to use Interfaces? [closed]
  6. When should one use interfaces?
  7. What is the difference between an abstract method and a virtual method?
  8. Functional programming vs Object Oriented programming [closed]
  9. Explanation of the UML arrows
  10. What is the rationale behind having companion objects in Scala?
  11. What is the difference between aggregation, composition and dependency? [duplicate]
  12. What is the dependency inversion principle and why is it important?
  13. Difference Between Cohesion and Coupling
  14. Do write-only properties have practical applications?
  15. Polymorphism – Define In Just Two Sentences [closed]
  16. DDD – the rule that Entities can’t access Repositories directly
  17. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  18. If-less programming (basically without conditionals) [closed]
  19. Are there any rules for OOP?
  20. What is the real difference between “Bastard Injection” and “Poor Man’s Injection”
  21. When to implement an interface and when to extend a superclass?
  22. Differences between Proxy and Decorator Pattern
  23. Mixin vs inheritance
  24. Does the Single Responsibility Principle work in OOP?
  25. What does ‘low in coupling and high in cohesion’ mean
  26. Learning/Implementing Design Patterns (For Newbies) [closed]
  27. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  28. When to use a Class in VBA?
  29. VBA: how to test for object equality (whether two variables reference the same object)
  30. Overloading functions

Leave a Comment