Exceptions in Java
In this chapter of the Java tutorial, we work with exceptions. Java uses exceptions to handle errors.
During the execution of our application many things might go wrong. A disk might get full and we cannot save our data. An Internet connection might go down while our application tries to connect to a site. A user fills invalid data to a form. These errors can crash the application, make it unresponsive, and in some cases even compromise the security of a system. It is a responsibility of a programmer to handle errors that can be anticipated.
Checked exceptions are error conditions that can be anticipated and recovered from (invalid user input, database problems, network outages, absent files). All subclasses of Exception except for RuntimeException and its subclasses are checked exceptions. IOException, SQLException, or PrinterException are examples of checked exceptions. Checked exceptions are forced by Java compiler to be either caught or declared in the method signature (using the throws keyword).
Java unchecked exceptions
Unchecked exceptions are error conditions that cannot be anticipated and recovered from. They are usually programming errors and cannot be handled at runtime. Unchecked exceptions are subclasses of java.lang.RuntimeException. ArithmeticException, NullPointerException, or BufferOverflowException belong to this group of exceptions. Unchecked exceptions are not enforced by the Java compiler.
Java errors
Errors are serious problems that programmers cannot solve. For example hardware or system malfunctions cannot be handled by applications. Errors are instances of the java.lang.Error class. Examples of errors include InternalError, OutOfMemoryError, StackOverflowError or AssertionError.
Errors and runtime exceptions are often referred to as unchecked exceptions.
Java try/catch/finally
The try, catch and finally keywords are used to handle exceptions. The throws keyword is used in method declarations to specify which exceptions are not handled within the method but rather passed to the next higher level of the program.
The throw keyword causes the declared exception instance to be thrown. After the exception is thrown, the runtime system attempts to find an appropriate exception handler. The call stack is a hierarchy of methods that are searched for the handler.
Java unchecked exception examples
Java checked exceptions include ArrayIndexOutOfBoundsException, UnsupportedOperationException, NullPointerException, and InputMismatchException.
ArrayIndexOutOfBoundsException
ArrayIndexOutOfBoundsException is hrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.
package com.zetcode;
public class ArrayIndexOutOfBoundsEx {
public static void main(String[] args) {
int[] n = { 5, 2, 4, 5, 6, 7, 2 };
System.out.format("The last element in the array is %d%n", n[n.length]);
}
}There is a bug in the above program. We try to access an element that does not exist. This is a programming error. There is no reason to handle this error: the code must be fixed.
System.out.format("The last element in the array is %d%n", n[n.length]);The array indexes start from zero. Therefore, the last index is n.length - 1.
$ java ArrayIndexOutOfBoundsEx.java Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 7 at com.zetcode.ArrayIndexOutOfBoundsEx.main(ArrayIndexOutOfBoundsEx.java:9)
A java.lang.ArrayIndexOutOfBoundsException is thrown by the runtime system. This is an example of an unchecked exception.
UnsupportedOperationException
UnsupportedOperationException is thrown to indicate that the requested operation is not supported.
package com.zetcode;
import java.util.List;
public class UnsupportedOperationEx {
public static void main(String[] args) {
var words = List.of("sky", "blue", "forest", "lake", "river");
words.add("ocean");
System.out.println(words);
}
}An immutable list is created with List.of() factory method. The immutable list does not support the add() method; therefore, we the UnsupportedOperationException is thrown when we run the example.
NullPointerException
NullPointerException is thrown when an application attempts to use an object reference that has the null value. For instance, we call an instance method on the object referred by a null reference.
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
public class NullPointerEx {
public static void main(String[] args) {
List<String> words = new ArrayList<>() {{
add("sky");
add("blue");
add("cloud");
add(null);
add("ocean");
}};
words.forEach(word -> {
System.out.printf("The %s word has %d letters%n", word, word.length());
});
}
}The example loops over a list of strings and determines the length of each of the strings. Calling length() on a null value leads to NullPointerException. To fix this, we either remove all null values from the list of check for a null value before calling length().
InputMismatchException
The Scanner class throws an InputMismatchException to indicate that the token retrieved does not match the pattern for the expected type. This exception is an example of an unchecked exception. We are not forced to handle this exception by the compiler.
package com.zetcode;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
public class InputMismatchEx {
public static void main(String[] args) {
System.out.print("Enter an integer: ");
try {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
System.out.println(x);
} catch (InputMismatchException e) {
Logger.getLogger(InputMismatchEx.class.getName()).log(Level.SEVERE,
e.getMessage(), e);
}
}The error prone code is placed in the try block. If an exception is thrown, the code jumps to the catch block. The exception class that is thrown must match the exception following the catch keyword.
try {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
System.out.println(x);
}The try keyword defines a block of statements which can throw an exception.
} catch (InputMismatchException e) {
Logger.getLogger(InputMismatchEx.class.getName()).log(Level.SEVERE,
e.getMessage(), e);
}The exception is handled in the catch block. We use the Logger class to log the error.
Checked exceptions
Java checked exceptions include SQLException, IOException, or ParseException.
SQLException
SQLException occurs when working with databases.
package com.zetcode;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MySqlVersionEx {
public static void main(String[] args) {
Connection con = null;
Statement st = null;
ResultSet rs = null;
String url = "jdbc:mysql://localhost:3306/testdb?useSsl=false";
String user = "testuser";
String password = "test623";
try {
con = DriverManager.getConnection(url, user, password);
st = con.createStatement();
rs = st.executeQuery("SELECT VERSION()");
if (rs.next()) {
System.out.println(rs.getString(1));
}
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
if (st != null) {
try {
st.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
}
}
}The example connects to a MySQL database and finds out the version of the database system. Connecting to databases is error prone.
try {
con = DriverManager.getConnection(url, user, password);
st = con.createStatement();
rs = st.executeQuery("SELECT VERSION()");
if (rs.next()) {
System.out.println(rs.getString(1));
}
}The code that might lead to an error is placed in the try block.
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(Version.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}When an exception occurs, we jump to the catch block. We handle the exception by logging what happened.
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
if (st != null) {
try {
st.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
}The finally block is executed whether we received and exception or not. We are trying to close the resources. Even in this process, there might be an exception. Therefore, we have other try/catch blocks.
IOException
IOException is thrown when an input/output operation fails. This may be due to insufficient permissions or wrong file names.
package com.zetcode;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class IOExceptionEx {
private static FileReader fr;
public static void main(String[] args) {
try {
char[] buf = new char[1024];
fr = new FileReader("src/resources/data.txt", StandardCharsets.UTF_8);
while (fr.read(buf) != -1) {
System.out.println(buf);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}When we read data from a file, we need to deal with the IOException. The exception can be thrown when we try to read the data with read() and to close the reader with close().
ParseException
ParseException is thrown when a parsing operation fails.
package com.zetcode;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class ParseExceptionEx {
public static void main(String[] args) {
NumberFormat nf = NumberFormat.getInstance(new Locale("sk", "SK"));
nf.setMaximumFractionDigits(3);
try {
Number num = nf.parse("150000,456");
System.out.println(num.doubleValue());
} catch (ParseException e) {
e.printStackTrace();
}
}
}In the example, we parse a localized number value to a Java Number. We handle the ParseException with try/catch statements.
Java throwing exceptions
The Throwable class is the superclass of all errors and exceptions in the Java language. Only objects that are instances of this class (or one of its subclasses) are thrown by the Java Virtual Machine or can be thrown by the Java throw statement. Similarly, only this class or one of its subclasses can be the argument type in a catch clause.
Programmers can throw exceptions using the throw keyword. Exceptions are often handled in a different place from where they are thrown. Methods can throw off their responsibility to handle exception by using the throws keyword at the end of the method definition. The keyword is followed by comma-separated list of all exceptions thrown by that method. Thrown exceptions travel through a call stack and look for the closest match.
package com.zetcode;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ThrowingExceptions {
public static void main(String[] args) {
System.out.println("Enter your age: ");
try {
Scanner sc = new Scanner(System.in);
short age = sc.nextShort();
if (age <= 0 || age > 130) {
throw new IllegalArgumentException("Incorrect age");
}
System.out.format("Your age is: %d %n", age);
} catch (IllegalArgumentException | InputMismatchException e) {
Logger.getLogger(ThrowingExceptions.class.getName()).log(Level.SEVERE,
e.getMessage(), e);
}
}
}In the example, we ask the user to enter his age. We read the value and throw an exception if the value is outside the range of the expected human age.
if (age <= 0 || age > 130) {
throw new IllegalArgumentException("Incorrect age");
}An age cannot be a negative value and there is no record of a person older than 130 years. If the value is outside of this range we throw a built-in IllegalArgumentException. This exception is thrown to indicate that a method has been passed an illegal or inappropriate argument.
} catch (IllegalArgumentException | InputMismatchException e) {
Logger.getLogger(ThrowingExceptions.class.getName()).log(Level.SEVERE,
e.getMessage(), e);
}Since Java 7, it is possible to catch multiple exceptions in one catch clause. However, these exceptions cannot be subclasses of each other. For example, IOException and FileNotFoundException cannot be used in one catch statement.
The following example will show how to pass the responsibility for handling exceptions to other methods.
The Battle of Thermopylae was fought between an alliance of Greek city-states, led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the course of three days, during the second Persian invasion of Greece.
We use this text file.
package com.zetcode;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class ThrowingExceptions2 {
public static void readFileContents(String fname) throws IOException {
BufferedReader br = null;
Path myPath = Paths.get(fname);
try {
br = Files.newBufferedReader(myPath, StandardCharsets.UTF_8);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} finally {
if (br != null) {
br.close();
}
}
}
public static void main(String[] args) throws IOException {
String fileName = "src/main/resources/thermopylae.txt";
readFileContents(fileName);
}
}This example reads the contents of a text file. Both readFileContents() and main() methods do not handle the potential IOException; we let JVM handle it.
public static void readFileContents(String fname) throws IOException {When we read from a file, an IOException can be thrown. The readFileContents() method throws the exception. The task to handle these exceptions is delegated to the caller.
public static void main(String[] args) throws IOException {
String fileName = "src/main/resources/thermopylae.txt";
readFileContents(fileName);
}The main() method also throws the IOException. If there is such an exception, it will be handled by JVM.
Java try-with-resources statement
The try-with-resources statement is a special kind of a try statement. It was introduced in Java 7. In parentheses we put one or more resources. These resources will be automatically closed at the end of the statement. We do not have to manually close the resources.
package com.zetcode;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TryWithResources {
public static void main(String[] args) {
String fileName = "src/main/resources/thermopylae.txt";
Path myPath = Paths.get(fileName);
try (BufferedReader br = Files.newBufferedReader(myPath,
StandardCharsets.UTF_8)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException ex) {
Logger.getLogger(TryWithResources.class.getName()).log(Level.SEVERE,
ex.getMessage(), ex);
}
}
}In the example, we read the contents of a file and use the try-with-resources statement.
try (BufferedReader br = Files.newBufferedReader(myPath,
StandardCharsets.UTF_8)) {
...An opened file is a resource that must be closed. The resource is placed between the square brackets of the try statement. The input stream will be closed regardless of whether the try statement completes normally or abruptly.
Java custom exception
Custom exceptions are user defined exception classes that extend either the Exception class or the RuntimeException class. The custom exception is cast off with the throw keyword.
package com.zetcode;
class BigValueException extends Exception {
public BigValueException(String message) {
super(message);
}
}
public class JavaCustomException {
public static void main(String[] args) {
int x = 340004;
final int LIMIT = 333;
try {
if (x > LIMIT) {
throw new BigValueException("Exceeded the maximum value");
}
} catch (BigValueException e) {
System.out.println(e.getMessage());
}
}
}We assume that we have a situation in which we cannot deal with big numbers.
class BigValueException extends Exception {
public BigValueException(String message) {
super(message);
}
}We have a BigValueException class. This class derives from the built-in Exception class. It passes the error message to the parent class using the super keyword.
final int LIMIT = 333;
Numbers bigger than this constant are considered to be "big" by our program.
if (x > LIMIT) {
throw new BigValueException("Exceeded the maximum value");
}If the value is bigger than the limit, we throw our custom exception. We give the exception a message "Exceeded the maximum value".
} catch (BigValueException e) {
System.out.println(e.getMessage());
}We catch the exception and print its message to the console.
In this part of the Java tutorial, we have talked about exceptions in Java.
