CODEWITHSUNDEEP
javaexception
AlexLipp
AlexLipp

Reputation: 149

How can I get a method to throw a custom exception I've created?

So my custom exception is PatternFormatException, and I've appended throws PatternFormatException, to the end of my method, but I'm wondering how I can actually get the method to physically throw it? Do I use if statements? i.e. 

  if //[doesn't_parse] throw PatternFormatException

This seems cumbersome for many different lines of code? Can I catch a more universal in built exception i.e. NumberFormatException, and then in the handling of this, throw my own exception?

Upvotes: 2

Views: 162

Answers (2)

Domi
Domi

Reputation: 24528

You throw an exception using the throw keyword:

throw new PatternFormatException(...);

Generally you want to catch exceptions as early as they occur and handle them properly. If you want your parser (or whatever program you are writing) to generate meaningful errors, it's usually a good idea to wrap any caught exception and re-throw it, embedded in a more meaningful exception, giving the user a better idea of how things went wrong.

Something like this:

try {
  doSomething();  // throws SomeException
  doSomethingElse();  // throws SomeOtherException
}
catch (Exception e) {
  throw new PatternFormatException(..., e);
}

generally is fine, if you know exactly what exceptions might happen and if all of them are properly encapsulated by PatternFormatException. However, the key idea of Exceptions in Java is that you are always aware of all the possible Exceptions that can happen. That is why Java forces you to add all possibly thrown Exceptions (except for RuntimeException) to the method declaration.

A safer design would be:

try {
  doSomething();  // throws SomeException
  doSomethingElse();  // throws SomeOtherException
}
catch (SomeException e) {
  throw new PatternFormatException(..., e);
}
catch (SomeOtherException e2) {
  throw new PatternFormatException(..., e2);
}
catch (Exception e3) {
  throw new UnexpectedPatternFormatException(..., e3);
}

Note that the first two catches call different constructors, and thus can handle different Exceptions differently. The last catch wraps an unexpected exception because your program encountered an exception (probably a RuntimeException) that you did not plan for. If users then complain about UnexpectedPatternFormatException, you can just go back to your code and fix the code so that the underlying Exception either does not get thrown anymore or gets wrapped in a more meaningful way. You can also just use a single UnexpectedMySomethingException class as the fall-back for all try/catch blocks that you have, to keep things a bit simpler.

One last word should be said about issues caused by Exceptions: Even though, Java uses Exceptions for all kinds of situations, even those that are largely not in the control of the Java programmer (e.g. when accessing files or even trying to parse strings as numbers), always be aware that throwing and catching Exceptions is actually quite expensive, which is why many people tend to avoid that. Only really use Exceptions, if performance is not of an issue (when the Exception is a rare event).

Also, Exceptions can threaten the integrity of your program's state if you throw an Exception and catch it too late, so that lines that should have been executed did not get executed (e.g. code for cleaning up resources or other code that is needed to keep the program state "correct"), and, as a result, the only safe thing to do is to shut down the program.

Upvotes: 5

buzzsawddog
buzzsawddog

Reputation: 662

If I understand your question correctly you could just do this:

If(somethingBad){
  throw new PatternFormatException();
}

As stated in a response below. If your going to check this exception over and over again you might want some Static Method/Class Method (use your programming brain). For example you could do something like:

void checkForException(String pattern, String check){
    If(!check.equals(pattern)){
      throw new PatternFormatException();
    }
}

Now all you have to do is:

try{
    checkForException("abc","123");
}catch(PatternFormatException pfe){
   System.out.println(pfe);  //Whatever you want to happen if the exception is thrown
}

Remember though, ONLY use exceptions for exceptional situations...

Have a read over this for more information on exceptions. I find that I next to never use exceptions.

Upvotes: 3

Related Questions