Is it possible to ignore an exception?

Question

You can try and do nothing about it:

public static void exceptionTest() {
    makeNullPointer(); //The compiler allows me not to check this
    try {
        throwAnException(); //I'm forced to handle the exception, but I don't want to
    } catch (Exception e) { /* do nothing */ }
}

Bear in mind, in real life this is extemely ill-advised. That can hide an error and keep you searching for dogs a whole week while the problem was really a cat(ch). _{^{(Come on, put at least a System.err.println() there - Logging is the best practice here, as suggested by @BaileyS.)}}

Unchecked exceptions in Java extend the RuntimeException class. Throwing them will not demand a catch from their clients:

// notice there's no "throws RuntimeException" at the signature of this method
public static void someMethodThatThrowsRuntimeException() /* no need for throws here */ {
    throw new RuntimeException();
}

Classes that extend RuntimeException won't require a throws declaration as well.

And a word from Oracle about it:

Here's the bottom line guideline: If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception.

There are 3 things you can do :

• Throw a RuntimeException (or something extending a RuntimeException, like NullPointerException, IllegalArgumentException,...), you don't have to catch these as they are unchecked exceptions.

• Catch the exception and do nothing (not recommended) :

  public static void exceptionTest() {
      makeNullPointer(); //The compiler allows me not to check this
      try {
          throwAnException(); //I'm forced to handle the exception, but I don't want to
      } catch (Exception e) {
          // Do nothing
      }
  }
  

• Change exceptionTest () declaration to say that it throws an Exception, and let the method calling it catch the Exception and do what is appropriate :

  public static void exceptionTest() throws Exception {
      makeNullPointer(); //The compiler allows me not to check this
      throwAnException(); //I'm no more forced to handle the exception
  }
  

In Java there is two kinds of Exceptions, Checked Exceptions and Unchecked Exceptions.

• Exception is a checked exception, must caught or thrown.
• NullPointerException is a RuntimeException, (the compiler doesn’t forces them to be declared in the throws claus) you can ignore it, ,but it still may occur in the Runtime, and your application will crash.

From Exception documentation:

The class Exception and any subclasses that are not also subclasses of RuntimeException are checked exceptions. Checked exceptions need to be declared in a method or constructor's throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.

From the RuntimeException documentation:

RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

RuntimeException and its subclasses are unchecked exceptions. Unchecked exceptions do not need to be declared in a method or constructor's throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.

No, it raises a compiler error. Being a checked exception, you must either catch it or propagate it by declaring your method as potentially throwing it. Check this and this.

Throw a RuntimeException or an exception which is derived from RuntimeException. Then the compiler will not force you to catch it.

The other answers are right, in that they correctly tell you what you should do, but it is actually possible to throw a undeclared checked exception. There are a few ways this can be done; the simplest is:

public void methodThatSecretlyThrowsAnException() {
    Thread.currentThread().stop(new Exception());
}

or if your goal is to wrap an existing method that does declare its exception

public void methodThatSecretlyThrowsAnException() {
    try {
        methodThatAdmitsItThrowsAnException();
    } catch(final Exception e) {
        Thread.currentThread().stop(e);
    }
}

(Needless to say, you should never do this.)