How to create custom exceptions in Java? [closed]

by

To define a checked exception you create a subclass (or hierarchy of subclasses) of java.lang.Exception. For example:

public class FooException extends Exception {
  public FooException() { super(); }
  public FooException(String message) { super(message); }
  public FooException(String message, Throwable cause) { super(message, cause); }
  public FooException(Throwable cause) { super(cause); }
}

Methods that can potentially throw or propagate this exception must declare it:

public void calculate(int i) throws FooException, IOException;

… and code calling this method must either handle or propagate this exception (or both):

try {
  int i = 5;
  myObject.calculate(5);
} catch(FooException ex) {
  // Print error and terminate application.
  ex.printStackTrace();
  System.exit(1);
} catch(IOException ex) {
  // Rethrow as FooException.
  throw new FooException(ex);
}

You’ll notice in the above example that IOException is caught and rethrown as FooException. This is a common technique used to encapsulate exceptions (typically when implementing an API).

Sometimes there will be situations where you don’t want to force every method to declare your exception implementation in its throws clause. In this case you can create an unchecked exception. An unchecked exception is any exception that extends java.lang.RuntimeException (which itself is a subclass of java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Methods can throw or propagate FooRuntimeException exception without declaring it; e.g.

public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}

Unchecked exceptions are typically used to denote a programmer error, for example passing an invalid argument to a method or attempting to breach an array index bounds.

The java.lang.Throwable class is the root of all errors and exceptions that can be thrown within Java. java.lang.Exception and java.lang.Error are both subclasses of Throwable. Anything that subclasses Throwable may be thrown or caught. However, it is typically bad practice to catch or throw Error as this is used to denote errors internal to the JVM that cannot usually be “handled” by the programmer (e.g. OutOfMemoryError). Likewise you should avoid catching Throwable, which could result in you catching Errors in addition to Exceptions.

More Related Contents:

  1. Causes of getting a java.lang.VerifyError
  2. How to use wait and notify in Java without IllegalMonitorStateException?
  3. Concurrent Modification Exception : adding to an ArrayList
  4. Should a retrieval method return ‘null’ or throw an exception when it can’t produce the return value? [closed]
  5. java.rmi.ServerException: RemoteException occurred in server thread (ClassNotFoundException)
  6. Can I catch multiple Java exceptions in the same catch clause?
  7. Differences between Exception and Error
  8. What could cause java.lang.reflect.InvocationTargetException?
  9. No-throw VirtualMachineError guarantees
  10. When to catch the Exception vs When to throw the Exceptions?
  11. Exception NoClassDefFoundError for CacheProvider
  12. java.rmi.ConnectException: Connection refused to host: 127.0.1.1;
  13. Differences between Runtime/Checked/Unchecked/Error/Exception
  14. When to use an assertion and when to use an exception
  15. Which part of throwing an Exception is expensive?
  16. Why does Java throw NullPointerException here?
  17. How can I avoid ResultSet is closed exception in Java?
  18. While constructing the default constructor can not handle exception : type Exception thrown by implicit super constructor
  19. Why am I getting “must be caught or declared to be thrown” on my program?
  20. JavaFX Exception in thread “main” java.lang.NoClassDefFoundError: javafx/application/Application
  21. Best way to throw exceptions in JNI code?
  22. In Java, is using throws Exception instead of throwing multiple specific exceptions good practice?
  23. When to log a stacktrace for a caught exception
  24. How can I catch all exceptions thrown through reading / writing a file?
  25. Print the stack trace of an exception
  26. Try-catch-finally and then again a try catch
  27. In Java, what is the difference between catch a generic exception and a specific exception (eg. IOException?)
  28. problems with java3D lib configuration
  29. Why does a Java Lambda which throws a Runtime Exception require brackets?
  30. Java 8 Supplier Exception handling with CompletableFuture

Leave a Comment