Panic in Minitab

import java.io.File;
import java.io.IOException;

public class ExceptionExample {
    public static void main(String[] args) {
        // We'll use exceptions throughout this site to check for
        // unexpected errors. This is the only program on the
        // site designed to throw an exception.
        throw new RuntimeException("a problem");

        // A common use of exceptions is to abort if a method
        // throws an exception that we don't know how to
        // (or want to) handle. Here's an example of
        // throwing an exception if we get an unexpected error when creating a new file.
        /*
        try {
            File file = new File("/tmp/file");
            if (!file.createNewFile()) {
                throw new IOException("Failed to create file");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        */
    }
}

Running this program will cause it to throw an exception, print an error message and stack trace, and exit with a non-zero status.

When the first exception in main is thrown, the program exits without reaching the rest of the code. If you’d like to see the program try to create a temp file, comment out the first exception.

$ javac ExceptionExample.java
$ java ExceptionExample
Exception in thread "main" java.lang.RuntimeException: a problem
    at ExceptionExample.main(ExceptionExample.java:9)

Note that unlike some languages which use return values for handling of many errors, in Java it is idiomatic to use exceptions for handling exceptional situations.

In Java, we use try-catch blocks to handle exceptions. The throw keyword is used to explicitly throw an exception. The RuntimeException used in this example is an unchecked exception, which doesn’t require explicit handling.

The IOException in the commented-out section is a checked exception, which must be either caught or declared to be thrown by the method. In this case, we catch it and re-throw it as a RuntimeException.

Remember that while exceptions are powerful for handling errors, they should be used judiciously. Overuse of exceptions, especially for control flow, can lead to code that’s hard to understand and maintain.