An Introduction to Exceptions - Ch. 3

Chapter 3: What are the most common Exceptions and what do they mean?
As we saw in the last chapter, there isn't only the standard Exception, but you also get special exceptions like NullPointerExce ption or ArrayIndexOutOf BoundsException. All of these extend the basic class Exception.

In general, you can sort Exceptions into two groups: Checked and unchecked Exceptions. Checked Exceptions are checked by the compiler at compilation time. Most Exceptions, that you will work with to control the flow of your program will be checked Exceptions.
Unchecked Exceptions are thrown at runtime and often mean, that you've made a mistake somewhere but the compiler couldn't know that.
All unchecked Exceptions extend RuntimeExceptio n, while all checked Exceptions don't.

There are a few Exceptions, that you will get ever so often. I've tried to make a list of the most common ones and to explain, what you can do to find, where it comes from. You should always look at the message you get from the compiler or at runtime - it will give you the line, in which it encountered the error.

• ArrayIndexOutOf BoundsException
  
  This Exception, as most of them do and all of them should, describes what has gone wrong very well - some Array index is out of the given bounds. So, for example, you have an Array like this
  Expand|Select|Wrap|Line Numbers

  1. int [] array = new int[3]
  and you are trying to access a nonexistent element, maybe like this
  Expand|Select|Wrap|Line Numbers

  1. array[3]
  This is incorrect, as arrays start with element 0.
  
  Often you get this error, when using a for-loop which runs to often. Check the given line and find out, why it's trying to find an element, that doesn't exist.
  
  The ArrayIndexOutOf BoundsException is a unchecked Exception.
  
• ClassCastExcept ion
  
  If you encounter a ClassCastExcept ion, there is an invalid cast somewhere. For example, the following code throws a ClassCastExcept ion:
  
  
  Expand|Select|Wrap|Line Numbers

  1. public class Exceptions {
  2.     public static void main(String[] args) {
  3.         // Anything extends java.lang.Object directly or indirectly and is therefore an Object
  4.         Object testClass1 = new Class1("1");
  5.         Object testClass2 = (Class2) testClass1;
  6.     }
  7. }
  8.  
  9. class Class1
  10. {
  11.     String x;
  12.  
  13.     public Class1(String x)
  14.     {
  15.         this.x = x;
  16.     }
  17. }
  18.  
  19. class Class2
  20. {
  21.     int x;
  22.  
  23.     public Class2(int x)
  24.     {
  25.         this.x = x;
  26.     }
  27. }
  28.  
  It does so, as it can not cast a Class1 Object to a Class2 Object. If you have created Classes yourself, normally you will have to tell the compiler how to cast them to another Class yourself:
  
  
  Expand|Select|Wrap|Line Numbers

  1. public class Exceptions {
  2.     public static void main(String[] args) {
  3.         // Now we've defined the cast ourselves and don't need to define the new Objects as Objects.
  4.         Class1 testClass1 = new Class1("1");
  5.         Class2 testClass2 = testClass1.toClass2();
  6.  
  7.         // If we do want to define them as Objects, it would work like this:
  8.         Object testClass1_2 = new Class1("1");
  9.         Object testClass2_2 = ((Class1) testClass1_2).toClass2();
  10.     }
  11. }
  12.  
  13. class Class1
  14. {
  15.     String x;
  16.  
  17.     public Class1(String x)
  18.     {
  19.         this.x = x;
  20.     }
  21.  
  22.     public Class2 toClass2()
  23.     {
  24.         return new Class2(Integer.parseInt(x));
  25.     }
  26. }
  27.  
  28. class Class2
  29. {
  30.     int x;
  31.  
  32.     public Class2(int x)
  33.     {
  34.         this.x = x;
  35.     }
  36. }
  37.  
  The ClassCastExcept ion is a unchecked Exception.
  
• ClassNotFoundEx ception
  
  This means, that a certain class cannot be found. Normally this happens, when you compile classes and try to run them without having compiled other classes, which are needed. It can also mean, that the needed classes are compiled, however not up to date. Try recompiling everything you need.
  
• FileNotFoundExc eption
  
  When you try to access a File, it may not exist. This code will throw a FileNotFoundExc eption:
  
  
  Expand|Select|Wrap|Line Numbers

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4.  
  5. public class Exceptions {
  6.     public static void main(String[] args) throws FileNotFoundException {
  7.         File file = new File("hello.txt");
  8.         FileInputStream iStream = new FileInputStream(file);
  9.     }
  10. }
  11.  
  WARNING: Please don't have a main method, which throws Exceptions. This should only be done for demonstration purposes. Catch and handle the Exceptions instead. A better way to handle this kind of situation would be:
  
  
  Expand|Select|Wrap|Line Numbers

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4.  
  5. public class Exceptions {
  6.     public static void main(String[] args){
  7.         try
  8.         {
  9.             File file = new File("hello.txt");
  10.             FileInputStream iStream = new FileInputStream(file);
  11.         }
  12.         catch(FileNotFoundException fnfe)
  13.         {
  14.             System.err.println(fnfe);
  15.         }
  16.     }
  17. }
  18.  
  The ClassNotFoundEx ception is a checked Exception.
  
• IOException: The Input-Output-Exception is an Exception, which is very commonly used. The FileNotFoundExc eption is one these and can therefore be caught with:
  
  
  Expand|Select|Wrap|Line Numbers

  1. catch(IOException ioe) {
  2.    //...
  3. }
  4.  
  The following code will throw a IOException:
  
  
  Expand|Select|Wrap|Line Numbers

  1. public static void throwIOException() throws IOException
  2. {
  3.    try 
  4.    {
  5.        OutputStream oStream = new FileOutputStream(new File("")); 
  6.       oStream.close(); 
  7.       oStream.write(0); 
  8.    }
  9.    // The FileNotFoundException extends IOException - however to get a basic 
  10.    // IOException, we do this: 
  11.    catch(IOException fnfe) 
  12.    {
  13.       IOException ioe = new IOException(); 
  14.       ioe.initCause(fnfe);
  15.       throw ioe; 
  16.     }
  17. }
  18.  
  This is also an Example of two things:
  • A wrapped exception - the try-catch-block catches one exception and throws another. This can be very useful in some cases.
  • Creating a chained Exception. This means, the Exception carries information about where it comes from (i.e. the "FileNotFoundEx ception"). The adding of this information is done with the line ioe.initCause(f nfe); and it can be retained with
    
    
    Expand|Select|Wrap|Line Numbers

    1. catch(IOException ioe) {
    2. {
    3.    System.err.println(ioe); 
    4.    System.err.println("Cause: " + ioe.getCause()); 
    5. }
    6.  
  The IOException is a checked Exception.
  
• NullPointerExce ption
  A NullPointerExce ption is thrown, when an Object has been defined, but not declared when you try to access it. To use the last example again, this code will throw a NullPointerExce ption:
  
  Expand|Select|Wrap|Line Numbers

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4.  
  5. public class Exceptions {
  6.     public static File file;
  7.     public static void main(String[] args){
  8.         try
  9.         {
  10.             FileInputStream iStream = new FileInputStream(file);
  11.         }
  12.         catch(FileNotFoundException fnfe)
  13.         {
  14.             System.err.println(fnfe);
  15.         }
  16.     }
  17. }
  18.  
  Check, if you have declared the Object, which you are trying to use in the Line given with the exception.
  The NullPointerExce ption is a unchecked Exception.

You may of course face an exception not mentioned in this list. Often, just checking the line mentioned by the Exception and thinking about the name of the exception leads you to the solution.

Back to chapter 2 or Continue to chapter 4