Exception handling facts for kids

In computer programming, an exception is like a special alarm that goes off when something unexpected happens. Imagine your computer program is following a recipe. If it suddenly needs an ingredient that isn't there, or tries to mix things in a way that doesn't make sense, an exception is "thrown." This tells the program, "Hey, something went wrong here, I can't continue as usual!" Instead of crashing, the program can try to handle this unexpected event.

Programmers try to make their programs "exception-safe." This means that even if an exception happens, the program won't break completely, lose important information, or mess up your files. There are different levels of how "safe" a program can be:

• No problems at all: The program is built so well that it almost never throws an exception. This is the safest, but also the hardest to do.
• Undo if something goes wrong: If an operation fails and an exception is thrown, the program makes sure that nothing changed. It's like trying to save a file, and if it fails, the original file is still perfectly fine.
• Basic safety: Some parts of the operation might have happened, but the program is still in a good, working state. It might not be exactly as it was before, but it's not broken.
• No leaks: The program might not be in a perfect state, but it won't crash or use up all your computer's memory. It will keep running, even if some data is not quite right.
• No safety: This is the worst. If something goes wrong, anything can happen. The program might crash, lose data, or cause other problems.

Usually, programmers try to "catch" these exceptions early. This stops small problems from becoming big ones.

What Happens When Things Go Wrong?

Imagine you have a list of numbers, like a shopping list. In programming, this is called an array. If your program tries to find the first item on a shopping list that doesn't exist yet, it's like asking for "the first thing on an empty list." This causes a special problem called a null reference.

Here's a simple example in a programming language called Java:

class SomeProgram {
  int[] SomeArray = null; // This array of numbers doesn't exist yet
  public static void main(String[] args) {
    System.out.println("The 1st number in the array is " + SomeArray[0] + "."); // This will cause an exception!
  }
}

In this code, `SomeArray` is set to `null`, which means it points to nothing. When the program tries to get `SomeArray[0]` (the first item), it can't find anything, so it "throws" a `NullPointerException`. This is a type of exception that means "you tried to use something that doesn't exist."

How to Catch an Exception

Programmers can use special commands to "catch" exceptions. This means they tell the program: "Try to do this, but if a specific problem happens, do something else instead."

Here's how the previous example can be fixed using `try` and `catch`:

class AnotherProgram {
  int[] SomeArray = null; // This array of numbers doesn't exist
  public static void main(String[] args) {
    try { // Try to do this part of the code
      System.out.println("The 1st number in the array is " + SomeArray[0] + "."); // This might cause a problem
    }
    catch (NullPointerException e) { // If a NullPointerException happens...
      System.err.println("Sorry.  I could not find the first number in the array."); // ...show this error message
      e.printStackTrace(); // ...and show where the problem happened
    }
  }
}

In this new code:

• The `try` block contains the code that might cause an exception.
• If a `NullPointerException` happens inside the `try` block, the program jumps to the `catch` block.
• The `catch` block then runs its own code. In this case, it prints a friendly error message and helps the programmer find where the mistake is. This stops the program from crashing completely.

Related pages

• Computer programming