Exception Types in Java

Most programs are written as a sequence of steps that the computer carries out one after another. Usually that sequence is the path the program follows from start to finish. Sometimes, though, something happens while the program is running that pulls it off that path. Programmers have a word for these moments: exception. This article explains what an exception does to the path a program takes, how Java represents exceptions, and why the word was chosen over the more familiar word error.

Keep one question in mind as you read: when something unusual happens, which statement runs next? The answer to that question is the core of what an exception is.

The phrase normal flow of control refers to the order in which a program's statements are executed when nothing unusual happens. Picture the statements as a list. The computer works down the list, finishing one statement before starting the next. Each statement's position determines when it runs.

Read the diagram from top to bottom. The top box is the ordinary path. The event in the middle is the point where that path is interrupted. The exception object is the form the event takes once it exists in the program. The try..catch handler sits at the bottom because exceptions are the kind of event a programmer may want to handle with a try..catch. The diagram maps the idea rather than every step the runtime performs.

The disruption is the defining feature. The event changes which part of the program runs next, instead of letting the statements continue in their planned order. Notice what the definition does not say. It does not say that an exception is always wrong, always caused by a bug, or always fatal. It says only that the event changes the path.

In Java, exceptions are represented as objects of type Exception. This matters because an object can be created, passed around, and examined like any other value in the program. An exception is not just an abstract idea floating in the background; it is something the program can actually hold and work with.

Exception is the general category. The actual exceptions a program meets are usually defined by subclasses of Exception, which are narrower classes built on top of it. So the general type describes the idea of a disruption, and each subclass describes a more specific kind of disruption.

Different subclasses represent different types of exceptions. Each one stands for a particular category of disruption, while all of them share the general Exception type. The diagram below shows the relationship the source describes: the general Exception type with specific subclasses beneath it.

The source names two example subclasses and then limits its discussion to them. It notes that many other exception types exist beyond these two. The source also does not describe any further relationship between these two subclasses, so the diagram shows them side by side rather than inventing a parent-child link between them.

It would be natural to call every disruption an error, but the source deliberately avoids that word. The reason is that in some cases an exception might not be considered an error at all. You can sometimes think of an exception as just another way to organize a program. An event that changes the path through the code is not always a mistake. It may simply be a situation the program was designed to route differently.