CS61B Guide
  • This site is now deprecated
  • Object Oriented Programming
    • Inheritance
    • Access Control
    • Dynamic Method Selection
    • Java Objects
    • Generic Types
  • Asymptotics
    • Asymptotic Analysis Basics
    • Amortization
    • Asymptotics Practice
  • Abstract Data Types
    • Collections
      • Arrays
      • Linked Lists
      • Sets
      • Stacks and Queues
    • Binary Trees
      • Heaps
      • Balanced BSTs
      • Tries
    • Graphs
    • Hashing and Hash Tables
    • Union Find (Disjoint Sets)
    • Comparables and Comparators
  • Sorting
    • Sorting
  • Algorithms
    • Minimax Algorithm
    • Searching
      • Binary Search
      • Depth First Search (DFS)
      • Breadth First Search (BFS)
    • Shortest Paths
      • Dijkstra's Algorithm
      • A* Search
    • Minimum Spanning Trees
      • Prim's Algorithm
      • Kruskal's Algorithm
  • Misc Topics
    • Modular Arithmetic and Bit Manipulation
    • Exceptions
    • More Resources
Powered by GitBook
On this page
  • Basics
  • Exceptions in Java
  • Creating Custom Exceptions
  • Try/Catch/Finally Example

Was this helpful?

  1. Misc Topics

Exceptions

PreviousModular Arithmetic and Bit ManipulationNextMore Resources

Last updated 2 years ago

Was this helpful?

Basics

An exception occurs when something unintended occurs and the interpreter must exit.

While this might sound like a bad thing, we can often throw our own exceptions to handle known errors or edge cases more gracefully.

Exceptions in Java

In Java, there are two types of exceptions: checked and unchecked.

Checked exceptions are handled during compile time, and are included in the method declaration. As an example:

public void openFile() throws IOException {
    ...
}
  • All children that override this method must also throw the same exceptions.

Unchecked exceptions are not handled during compile time, and thus are thrown during runtime. All Error or RuntimeException types are unchecked; all other exceptions are checked. Some examples of unchecked exceptions are dividing by zero (ArithmeticException), or accessing an index that doesn't exist (IndexOutOfBoundsException).

Creating Custom Exceptions

We can use the throw keyword to create exceptions with custom error messages as follows:

public void divide(int a, int b) {
    if (b == 0) {
        throw new Exception("Error Message");
    } else {
        return a / b;
    }
}

This is often used within a try catch block, as such:

public void divide2() {
    int a = 0;
    try {
        return 10 / 0;
    } catch(Exception e) {
        System.out.println("oops!");
    }
 }

An alternate to custom exceptions is to simply handle exception cases. For example, we can add a check to make sure a number is not zero before running a division operation.

Try/Catch/Finally Example

Let's check your understanding of exception handling!

static String tryCatchFinally() {
        try {
            System.out.println("trying");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("catching");
            return "done catch";
        } finally {
            System.out.println("finally");
        }
    }

What will be printed (and in what order) when tryCatchFinally() is run?

First, trying will be printed.

Since an Exception is thrown, the catch block will run next, so catching is printed next.

Since finally blocks always run regardless of result, finally is printed last.

Suppose the same code were run, but without the catch block. What would this code do?

static String tryFinally() {
        try {
            System.out.println("trying");
            throw new Exception();
        } finally {
            System.out.println("finally");
        }
}

If the try block throws an uncaught Exception (i.e. if catch block does not exist or catch block does not handle the type of Exception that is thrown in the try block), Java halts execution of the try block, executes the finally block, then raises a runtime error. So, the following sequence would occur: 1. trying is printed. 2. finally is printed. 3. The program exits with a RuntimeException.

Some of the more common Exception types in Java.