Should a retrieval method return 'null' or throw an exception when it can't produce the return value? [closed]

Question

I am using java language,I have a method that is supposed to return an object if it is found.

If it is not found, should I:

1. return null
2. throw an exception
3. other

Which is the best practise or idiom?

Factorial

Whatever you do, make sure you document it. I think this point is more important than exactly which approach is "best". – County

This depends on the prevailing idioms of the programming language. Please tag this question with a programming language tag. – Rabideau

Returning null may only mean success or failure which very often isn't much of information (some methods may fail in many ways). Libraries should better throw exceptions to make errors explicit and this way the main program can decide how to handle the error on a higher level (in contrast to builtin error handling logic). – Vacate

Seems to me that the real question being asked is if we should consider it exceptional for an entity to be not found, and if so, why? No one really answered sufficiently how to come to that conclusion, and now the Q&A is closed. A real shame that the industry hasn't come to consensus on this important topic. Yes, I know it depends. So, explain why it depends with more than "if exceptional, throw" – Melly

Answer 1

If you are always expecting to find a value then throw the exception if it is missing. The exception would mean that there was a problem.

If the value can be missing or present and both are valid for the application logic then return a null.

More important: What do you do other places in the code? Consistency is important.

Interception

@Ken: +1, it would be nice to mention that if you do throw an exception, but can detect it a priori (like HasItem(...)), then the user should provide said Has* or Contains method. – Kinnon

If you throw exceptions in model methods, it forces the developer to develop try/catch blocks from the calling scope, which ensures that the routines calling those model methods are handled properly from that scope. Otherwise, the developer could do whatever they want. Consider it an interface for calling model methods, if you will. If the data is not there, it's likely you will have to do some workaround anyway. – Accommodation

Instead of returning a value or null when the value is missing, consider returning a Maybe<T>. See mikehadlow.blogspot.nl/2011/01/monads-in-c-5-maybe.html. – Dresser

In a @ErwinRooijakkers design choice way, as of Java 8 you could also return an Optional<T> – Epp

In the face of ambiguity, it is tempting to pick one approach and stick with it consistently. I think we have to think carefully which one is more appropriate and judge it on a case-by-case basis. Contextually similar cases can then be treated in a consistent way, and determining the context goes beyond looking at return types. – Richly

I find it a bit disturbing every answer echoes the same proverb: "If it's exceptional, throw." Most engineers are going to be familiar with this principle. In my opinion, the real question here is how to determine if it should be considered exceptional. The OP is looking for the best practice in regards to something like a repository pattern for example. Is it typically considered exceptional for an object not to exist given a primary key? Yes, that is something his domain will determine, but what do most experts with years of experience suggest? That's the type of answer we should see. – Melly

That question is really a matter of opinion it seems. People talk about remaining consistent, but the answers here aren't even consistent. Some seem to think it's proper to throw, while others think you should return a null. And so while your team's project may stay consistent, the moment you start using someone else's library, you may be facing inconsistency because no clear industry requirements for this common scenario have been defined. "If the value can be missing or present and both are valid...return null" I'd follow this up with the Q how should one determine if both are valid? – Melly

@Melly I think a guiding principal is what parameters are passed to the function. If you pass an identity, like you mention a primary key, then it should be considered exceptional if that item is not found, because it indicates an inconsistent state in the system. Example: GetPersonById(25) would throw if that person has been deleted, but GetPeopleByHairColor("red") would return an empty result. So, I think the parameters say something about the expectations. – Interruption

Consistency is important! – Classicize

Answer 2

Only throw an exception if it is truly an error. If it is expected behavior for the object to not exist, return the null.

Otherwise it is a matter of preference.

Thales

I don't agree. You can throw exceptions as status codes: "NotFoundException" – Kilt

It certainly shouldn't be a matter of preference. That's how we end up with inconsistent code - if not among your team's code, then almost certainly when intertwining other developers code with your own (external libraries). – Melly

I think handling the null case is much easier than "NotFoundException". Think about how many lines of try-catch you have to write around every single retrival request that throws a "NotFoundException"... It's painful to ready all that code in my eyes. – Trammel

i would like to quote Tony Hoare: "I call it my billion-dollar mistake". I would not return null, i either throw an exception and handle it correctly, or return an empty object. – Horacehoracio

@Trammel Don't catch exceptions you can't resolve! If it's an erroneous situation, propagate it out to the top level & fail the request/ UI action. Best practice is to throw often, catch rarely. literatejava.com/exceptions/… – Sarchet

Answer 3

As a general rule, if the method should always return an object, then go with the exception. If you anticipate the occasional null and want to handle it in a certain way, go with the null.

Whatever you do, I highly advise against the third option: Returning a string that says "WTF".

Lightless

Plus one because in the good old days i did that more than a couple of times as a quick dirty "temporal" fix... no good idea. Specially if its going to be reviewed if you are a student. – Blizzard

I was going to down vote since the WTF options seemed awesome to me...but apparently I have a heart – Marrufo

throw new WtfExcepti😲n – Faultless

I think it would be helpful if this answer talked about reasons why a method would always return an object versus "an occasional null". What warrants that type of situation? Give an example of when such a circumstance might exist. – Melly

Answer 4

If null never indicates an error then just return null.

If null is always an error then throw an exception.

If null is sometimes an exception then code two routines. One routine throws an exception and the other is a boolean test routine that returns the object in an output parameter and the routine returns a false if the object was not found.

It's hard to misuse a Try routine. It's real easy to forget to check for null.

So when null is an error you just write

object o = FindObject();

When the null isn't an error you can code something like

if (TryFindObject(out object o)
  // Do something with o
else
  // o was not found

Kilimanjaro

This would be a more useful suggestion if C# provided real tuples, so we could avoid using an [out] parameter. Still, this is the preferred pattern, so +1. – Toodleoo

In my opinion, the try approach is the best one. You don't have to look up then what happens if the object cannot be returned. With a Try method, you immediately know what to do. – Bathypelagic

reminds me the find and findOrFail from Laravel Eloquent – Goebel

@ErikForbes I know your comment is old, but wouldn't the answer have been to define a multi-property object that would be returned from the TryFindObject method? Tuples seem more of a lazy paradigm for programmers who don't want to take the time to define an object that encapsulates multiple values. That is essentially all tuples are at the core anyways. – Melly

@Melly - Named Tuple Literals are an option, IMO. This is a link to an async Try Get pattern with tuples. #1627097 – Kristiekristien

Answer 5

I just wanted to recapitulate the options mentioned before, throwing some new ones in:

1. return null
2. throw an Exception
3. use the null object pattern
4. provide a boolean parameter to you method, so the caller can chose if he wants you to throw an exception
5. provide an extra parameter, so the caller can set a value which he gets back if no value is found

Or you might combine these options:

Provide several overloaded versions of your getter, so the caller can decide which way to go. In most cases, only the first one has an implementation of the search algorithm, and the other ones just wrap around the first one:

Object findObjectOrNull(String key);
Object findObjectOrThrow(String key) throws SomeException;
Object findObjectOrCreate(String key, SomeClass dataNeededToCreateNewObject);
Object findObjectOrDefault(String key, Object defaultReturnValue);

Even if you choose to provide only one implementation, you might want to use a naming convention like that to clarify your contract, and it helps you should you ever decide to add other implementations as well.

You should not overuse it, but it may be helpfull, espeacially when writing a helper Class which you will use in hundreds of different applications with many different error handling conventions.

Knew

I like the clear function names, especially orCreate and orDefault. – Manly

Most of this can be more cleanly written with Expected<T> findObject(String) where Expected<T> has the functions orNull(), orThrow(), orSupplied(Supplier<T> supplier), orDefault(T default). This abstracts the getting of the data from the error handling – James

I didn't know about Expected<T> until now. I seems to be pretty new and might not have existed when I wrote the original answer. Maybe you should make your comment a proper answer. – Knew

Also, Expected<T> is a C++ template. Are there implementations of it in other object oriented languages as well? – Knew

In Java 8, returning Optional<T> (called Maybe<T>, etc. in other languages) is an option as well. This clearly indicates to the caller that returning nothing is a possibility, and won't compile if the caller hasn't handled that possibility, as opposed to null, which (in Java anyway) will compile even if the caller doesn't check it. – Rhythmical

Answer 6

Use the null object pattern or throw an exception.

Huntlee

This is the real answer. Returning null is a terrible habit of lazy programmers. – Taliped

I can't believe this answer hasn't been voted to the top yet. This IS the real answer, and either approach is dead-easy and saves a lot of code-bloat or NPEs. – Autumnautumnal

sourcemaking.com/design_patterns/null_object – Autumnautumnal

If one uses the null object pattern, how would one distinguish the case where the key is mapped to the null object from the case where the key has no mapping? I would think returning a meaningless object would be far worse than returning null. Returning null to code that's not prepared to handle it will generally result in an exception being thrown. Not the optimal choice of exception, but an exception nonetheless. Returning a meaningless object is more likely to result in the code incorrectly regarding meaningless data as correct. – Vickievicksburg

How would the null object behave for an entity lookup? E.g., Person somePerson = personRepository.find("does-not-exist"); Let's assume this method returns a null object for ID does-not-exist. What would then be the correct behavior for somePerson.getAge()? Right now, I'm not yet convinced the null object pattern is the right solution for entity lookups. – Decuple

That why I said OR throw an exception, if it does not make sense in your case to propagate a NullPerson. In fact, I think that for entity lookups the best approach is to throw, then your controller/service/model/whatever will catch it and decide if it rethrow or return a null object. But yes your data access layer should throw, exceptions are easier to catch/debug than wondering why you have a null somewhere in the chain. – Huntlee

@Vickievicksburg The null object should be on a different inheritance branch e.g. RealRecord : RecordBase and NullRecord : RecordBase. Then anything taking a RealRecord can't possibly take a NullRecord. RecordBase communicates it could be either be real or null, and should itself be abstract. – Holladay

@SamuelDanielson: One of the major reasons that nulls are useful is that there needs to be a way of representing the state of an array element which hasn't been written yet, and it's useful to have a way of copying the state of array elements that may or may not have been written. If one wanted to have an array pre-populated so every item contains a NullRecord, all code that attempts to read the array would have to convert a RecordBase reference to a RealRecord reference, failing if the item is actually a NullRecord, and I don't see what one would have gained. – Vickievicksburg

@Vickievicksburg I didn't see a language tag in the question. C++, C#, and Rust use the word "Default" in their standard libraries to differentiate from Null in that case. If we actually look at our options across many languages we can express errors with exceptions, sentinels, defaults, nulls, sum types, unions, tagged unions, folded unions, product types (isValid? attribute), etc. I guess it just depends on how much you want the type system to help, and how much errors should be allowed to extend a module's unchecked interface. – Holladay

@SamuelDanielson: If one wants to be able to have a T[] with an arbitrary generic type T, allow elements to be read in cases where can't be statically proven to have been written, and define the behavior of such a read, then it must define a default state for array items that haven't been written yet. C# provides a uniform syntax to refer to the default value of any arbitrary T; for reference types, it yields null; for numeric types, it's zero; for structure types, it yields a structure with all fields holding default values. – Vickievicksburg

Answer 7

Advantages of throwing an exception:

1. Cleaner control flow in your calling code. Checking for null injects a conditional branch which is natively handled by try/catch. Checking for null doesn't indicate what it is you're checking for - are you checking for null because you're looking for an error you're expecting, or are you checking for null so you don't pass it further on downchain?
2. Removes ambiguity of what "null" means. Is null representative of an error or is null what is actually stored in the value? Hard to say when you only have one thing to base that determination off of.
3. Improved consistency between method behavior in an application. Exceptions are typically exposed in method signatures, so you're more able to understand what edge cases the methods in an application account for, and what information your application can react to in a predictable manner.

For more explanation with examples, see: http://metatations.com/2011/11/17/returning-null-vs-throwing-an-exception/

Hexastich

+1 because point 2 is excellent - null does not have the the same meaning as not found. This become more important when dealing with dynamic languages where Null could actually be the object being stored/retrieved by the function - and in that case – Cowan

+1 for point #2. Is null an error? Is null what is stored for the given key? Is null indicative that the key does not exist? These are the real line of questions that make it clear returning null is almost never correct. This is likely the best answer here as everyone else has just been throwing up the ambiguous "If it's exceptional, throw" – Melly

Exceptions may incur a performance penalty compared to returns (e.g. in Java), though. And unchecked exceptions (e.g. in Java) may surface in unintended places. – Carding

Answer 8

it depends if your language and code promotes: LBYL (look before you leap) or EAFP (easier to ask forgiveness than permission)

LBYL says you should check for values (so return a null)
EAFP says to just try the operation and see if it fails (throw an exception)

though I agree with above.. exceptions should be used for exceptional/error conditions, and returning a null is best when using checks.

---

EAFP vs. LBYL in Python:
http://mail.python.org/pipermail/python-list/2003-May/205182.html (Web Archive)

Gymnastics

In some cases, EAFP is the only meaningful approach. In a concurrent map/dictionary, for example, there's no way to ask whether a mapping will exist when it is requested. – Vickievicksburg

Answer 9

Just ask yourself: "is it an exceptional case that the object is not found"? If it is expected to happen in the normal course of your program, you probably should not raise an exception (since it is not exceptional behavior).

Short version: use exceptions to handle exceptional behavior, not to handle normal flow of control in your program.

-Alan.

Tambourin

Answer 10

Be consistent with the API(s) you're using.

Aver

Answer 11

Exceptions are related to Design by Contract.

The interface of an objects is actually a contract between two objects, the caller must meet the contract or else the receiver may just fail with an exception. There are two possible contracts

1) all input the method is valid, in which case you must return null when the object is not found.

2) only some input is valid, ie that which results in a found object. In which case you MUST offer a second method that allows the caller to determine if its input will be correct. For example

is_present(key)
find(key) throws Exception

IF and ONLY IF you provide both methods of the 2nd contract, you are allowed to throw an exception is nothing is found!

String

Answer 12

Here are a couple more suggestions.

If returning a collection, avoid returning null, return an empty collection which makes enumeration easier to deal with without a null check first.

Several .NET API's use the pattern of a thrownOnError parameter which gives the caller the choice as whether it is really an exceptional situation or not if the object is not found. Type.GetType is an example of this. Another common pattern with BCL is the TryGet pattern where a boolean is returned and the value is passed via an output parameter.

You could also consider the Null Object pattern in some circumstances which can either be a default or a version with no behaviour. The key is avoid null checks throughout the code base. See here for more information Link

Sinclair

Answer 13

Depends on what it means that the object is not found.

If it's a normal state of affairs, then return null. This is just something that might happen once in an while, and the callers should check for it.

If it's an error, then throw an exception, the callers should decide what to do with the error condition of missing object.

Ultimately either would work, although most people generally consider it good practice to only use Exceptions when something, well, Exceptional has happened.

Lugansk

How would you elaborate on the "normal state of affairs" statement and what criteria will you use to distinguish it with an error. – Selie

@Selie I found a relevant discussion on Software Engineering about what the normal state of affairs is – Sanasanabria

Answer 14

I prefer to just return a null, and rely on the caller to handle it appropriately. The (for lack of a better word) exception is if I am absolutely 'certain' this method will return an object. In that case a failure is an exceptional should and should throw.

Pinniped

Answer 15

referring only to the case where null is not considered an exceptional behavior i am definitely for the try method, it is clear, no need to "read the book" or "look before you leap" as was said here

so basically:

bool TryFindObject(RequestParam request, out ResponseParam response)

and this means that the user's code will also be clear

...
if(TryFindObject(request, out response)
{
  handleSuccess(response)
}
else
{
  handleFailure()
}
...

Southport

Answer 16

In some functions I add a parameter:

..., bool verify = true)

True means throw, false means return some error return value. This way, whoever uses this function has both options. The default should be true, for the benefit of those who forget about error handling.

Ibbetson

Answer 17

Return a null instead of throwing an exception and clearly document the possibility of a null return value in the API documentation. If the calling code doesn't honor the API and check for the null case, it will most probably result in some sort of "null pointer exception" anyway :)

In C++, I can think of 3 different flavors of setting up a method that finds an object.

Option A

Object *findObject(Key &key);

Return null when an object can't be found. Nice and simple. I'd go with this one. The alternative approaches below are for people who don't hate out-params.

Option B

void findObject(Key &key, Object &found);

Pass in a reference to variable that will be receiving the object. The method thrown an exception when an object can't be found. This convention is probably more suitable if it's not really expected for an object not to be found -- hence you throw an exception to signify that it's an unexpected case.

Option C

bool findObject(Key &key, Object &found);

The method returns false when an object can't be found. The advantage of this over option A is that you can check for the error case in one clear step:

if (!findObject(myKey, myObj)) { ...

Bedizen

Answer 18

If the method returns a collection, then return an empty collection (like sayed above). But please not Collections.EMPTY_LIST or such! (in case of Java)

If the method retrives a single object, then You have some options.

1. If the method should always find the result and it's a real exception case not to find the object, then you should throw an exception (in Java: please an unchecked Exception)
2. (Java only) If you can tolerate that the method throws a checked exception, throw a project specific ObjectNotFoundException or the like. In this case the compiler says you if you forget to handle the exception. (This is my preferred handling of not found things in Java.)
3. If you say it's really ok, if the object is not found and your Method name is like findBookForAuthorOrReturnNull(..), then you can return null. In this case it is strongly recomminded to use some sort of static check or compiler check, wich prevents dereferencing of the result without a null check. In case of Java it can be eg. FindBugs (see DefaultAnnotation at http://findbugs.sourceforge.net/manual/annotations.html) or IntelliJ-Checking.

Be careful, if you decide to return a null. If you are not the only programmer in project you will get NullPointerExceptions (in Java or whatever in other Languages) at run time! So don't return nulls which are not checked at compile time.

Pillsbury

Not if the code was properly written to expect null. See top-voted answer for more. – Temper

But only if you ensure at compile time, that all nulls are checked. This can be done, using FindBugs @NutNull at package level and mark your method as "may return null". Or to use a language like Kotlin or Nice. But it is much more simplier not to return null. – Pillsbury

"Simpler", maybe. But often plain incorrect – Temper

Sorry, but what is incorrect if a method, which promises to find a book, can't find them and throws an exception? Do you know the "Billion Dollar Mistake"? infoq.com/presentations/… – Pillsbury

Again: Read the top-voted answer for more information. Basically: If it's a potentially-expected result that the book requested can't be found, an exception is the wrong thing to do when the requested book is simply not found, as opposed to some error occurring. – Temper

The top-voted answer must not be the only right. I disagree the answer. Also Robert C. Martin (in Clean Code: A Handbook of Agile Software Craftsmanshi) and Michael Feathers disagree. And new programming languages like Kotlin and Nice subscribe for the view. And. Perhaps I take it to heart too much, but why did you voted me down? I did not break a rule and my answer is not so bad. – Pillsbury

You are misunderstanding a lot here. You are applying conditional advice universally, which is almost always a bad thing to do. Read the rest of the up voted answers, too. Your answer just states an absolute, and presents extremely faulty logic for it. – Temper

I have rewritten the answer. The previous answer was only for Java. – Pillsbury

Answer 19

Unfortunately JDK is inconsistent, if you trying access non existing key in resource bundle, you get not found exception and when you request value from map you get null if it doesn't exists. So I would change winner answer to the following, if found value can be null, then raise exception when it isn't found, otherwise return null. So follow to the rule with one exception, if you need to know why value isn't found then always raise exception, or..

Tatum

Answer 20

Prefer returning null --

If the caller uses it without checking, the exception happens right there anyway.

If the caller doesn't really use it, don't tax him a try/catch block

Brigitta

Answer 21

Or return an Option

An option is basically a container class that forces the client to handle booth cases. Scala has this concept, look up it's API.

Then you have methods like T getOrElse(T valueIfNull) on this object thet either return the found object, or an allternative the client specifieces.

Black

Answer 22

Generally it should return null. The code calling the method should decide whether to throw an exception or to attempt something else.

Elamite

Answer 23

If it's important for client code to know the difference between found and not found and this is supposed to be a routine behavior, then it's best to return null. Client code can then decide what to do.

Varner

Answer 24

If you are using a library or another class which throws an exception, you should rethrow it. Here is an example. Example2.java is like library and Example.java uses it's object. Main.java is an example to handle this Exception. You should show a meaningful message and (if needed) stack trace to the user in the calling side.

Main.java

public class Main {
public static void main(String[] args) {
    Example example = new Example();

    try {
        Example2 obj = example.doExample();

        if(obj == null){
            System.out.println("Hey object is null!");
        }
    } catch (Exception e) {
        System.out.println("Congratulations, you caught the exception!");
        System.out.println("Here is stack trace:");
        e.printStackTrace();
    }
}
}

Example.java

/**
 * Example.java
 * @author Seval
 * @date 10/22/2014
 */
public class Example {
    /**
     * Returns Example2 object
     * If there is no Example2 object, throws exception
     * 
     * @return obj Example2
     * @throws Exception
     */
    public Example2 doExample() throws Exception {
        try {
            // Get the object
            Example2 obj = new Example2();

            return obj;

        } catch (Exception e) {
            // Log the exception and rethrow
            // Log.logException(e);
            throw e;
        }

    }
}

Example2.java

 /**
 * Example2.java
 * @author Seval
 *
 */
public class Example2 {
    /**
     * Constructor of Example2
     * @throws Exception
     */
    public Example2() throws Exception{
        throw new Exception("Please set the \"obj\"");
    }

}

Cryptocrystalline

If the exception to be thrown from the function is not a runtime exception, and the caller is expected to handle it (instead of just terminating the program), then instead of throwing an exception from an internal subsystem that the caller can't expect, it would be better to wrap the internal exception with an external checked exception, while 'chaining' the internal exception so that someone debugging can figure out why the external exception was thrown. For instance, example1 could use 'throw new MyCheckedException("Please set the \"obj\"", e)' to include 'e' in the thrown exception. – Rhythmical

Answer 25

Exceptions should be exceptional. Return null if it is valid to return a null.

Brigade

More or less true. See boost.org/community/error_handling.html – Provencher

Answer 26

Return a null, exceptions are exactly that: something your code does that isn't expected.

Backset

Answer 27

I agree with what seems to be the consensus here (return null if "not found" is a normal possible outcome, or throw an exception if the semantics of the situation require that the object always be found).

There is, however, a third possibility that might make sense depending on your particular situation. Your method could return a default object of some sort in the "not found" condition, allowing calling code to be assured that it will always receive a valid object without the need for null checking or exception catching.

Gow

Answer 28

Don't think anyone mentioned the overhead in exception handling - takes additional resources to load up and process the exception so unless its a true app killing or process stopping event (going forward would cause more harm than good) I would opt for passing back a value the calling environment could interpret as it sees fit.

Wardship

Answer 29

As long as it's supposed to return a reference to the object, returning a NULL should be good.

However, if it's returning the whole bloody thing (like in C++ if you do: 'return blah;' rather than 'return &blah;' (or 'blah' is a pointer), then you can't return a NULL, because it's not of type 'object'. In that case, throwing an exception, or returning a blank object that doesn't have a success flag set is how I would approach the problem.

Bartle

Answer 30

It not containing the object can happen during normal operations and should be dealt with by the caller return NULL.

If not containing the object indicates a bug by the calling code or internal state then do an assert.

If not containing the object indicates an infrequent event. (Like someone deleted an item from the store while you were checking out the item at the same time.) Then throw an exception.

Heisenberg

Answer 31

In data layer code, I some times use the following code, allowing the caller to decide if "object not found" means an error has occured.

DataType GetObject(DBConnection conn, string id, bool throwOnNotFound) {
    DataType retval = ... // find object in database
    if (retval != null || ! throwOnNotFound) {
        return retval;
    } else {
        throw new NoRowsFoundException("DataType object with id {id} not found in database");
    }
}

DataType GetObject(DBConnection conn, string id) {
    return GetObject(conn, id, true);
} 

Joaquinajoash

Answer 32

The "other" option could be to let the find method take an additional parameter with a default object that would be returned if the sought for object cannot be found.

Otherwise I'd just return null unless it really is an exceptional case when the object isn't found.

Cyanohydrin

Answer 33

That depends on your method. If you method is supposed to always return a valid object and none is found, throwing an exception is the way to go. If the method is just ment to return an object which might or might not be there (like perhaps a image on a contact person) you shouldn't raise an error.

You might also want to expose a method returning a boolean true/false if this method actually will return an object so you don't have to either a) check for null or b) catch an exception

Latish

Answer 34

If not finding it is an exceptional event (i.e. it should be there under normal circumstances), then throw. Otherwise, return a "not found" value (can be null, but does not have to), or even have the method return a boolean for found/notfound and an out parameter for the actual object.

Dissent

Answer 35

It depends on the nature of the method and how it will be used. If it is normal behavior that the object may not be found, then return null. If it is normal behavior that the object is always found, throw an exception.

As a rule of thumb, use exceptions only for when something exceptional occurs. Don't write the code in such a way that exception throwing and catching is part of its normal operation.

Illboding

Answer 36

That really depends on if you expect to find the object, or not. If you follow the school of thought that exceptions should be used for indicating something, well, err, exceptional has occured then:

• Object found; return object
• Object not-found; throw exception

Otherwise, return null.

Veldaveleda