Java exception handling

Exceptions are some errors in the program, but not all errors are exceptions, and sometimes mistakes can be avoided.

For example, your code less a semicolon, then run out of the results is to prompt wrong java.lang.Error; if you use System.out.println (11/0), then you are doing because you use a divisor 0 It will be thrown java.lang.ArithmeticException exception.

There are many reasons for an exception occurs, usually contains the following categories:

• User input illegal data.
• To open a file does not exist.
• Network communication connection is interrupted or JVM memory overflow.

These exceptions either because of user error caused some procedural errors caused because there are other physical errors. -

To understand Java exception handling is how it works, you need to have the following three types of exceptions:

• Checked exception: the most representative checked exception is an exception due to user error or a problem, it is the programmer unforeseeable. For example when you want to open a file does not exist, an exception occurs, the exception can not be simply ignored at compile time.
• Exception is likely to be a programmer to avoid abnormal operation: run-time exception. In contrast with the checked exception, the runtime exception can be ignored at compile time.
• Error: error is not abnormal, but from the question of control of the programmer. Error in the code are usually ignored. For example, when a stack overflow, an error occurs, they can not check at compile time.

Exception class hierarchy

All exception classes inherit from java.lang.Exception subclass.

Exception class is a subclass of Throwable class. In addition to the Exception class, Throwable there is a subclass of Error.

Java programs usually do not catch the error. Error generally occurs when a serious fault, they are visible outside Java program processing.

Error runtime environment used to indicate an error occurs.

For example, JVM memory overflow. In general, the program does not recover from the error.

Exception class has two main sub-categories: IOException class and RuntimeException class.

Built-in Java class (the next will be explained), it has most of the usual checks and unchecked exception.

Built-in Java exception class

Java language defines several exception classes in the standard java.lang package.

Standard runtime exception classes are subclasses of the most common exception classes. Since java.lang package is loaded by default to all Java programs, so most from the runtime exception classes inherited abnormalities can be used directly.

According to various Java class library also defines a number of other exceptions, the following table lists the Java unchecked exception.

The following table lists the Java defined in the java.lang package checked exception classes.

Anomaly

The following list is the main method Throwable class:

Catch the exception

Use try and catch keywords can catch the exception. try / catch block in place exceptions that might occur.

Syntax try / catch block code is called a protection code using try / catch is as follows:

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

Catch statement contains an exception to capture the type of statement. When the protection code block when an exception occurs, try the back of the catch block will be checked.

If the exception contained in the catch block, the exception will be passed to the catch block, and pass a parameter to this method is the same.

Examples

The following example has declared a two-element array, when the code tries to access the third element of the array when it will throw an exception.

// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{

   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

The above code compile and run the following output:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Multiple catch blocks

A plurality of catch code blocks after the code block is called a try to follow multiple capture.

Multiple catch block syntax is as follows:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }

The above code snippet contains three catch blocks.

You can add any number of catch blocks behind the try statement.

If an exception occurs in the protection code, an exception is thrown to the first catch block.

If you throw the data type mismatch exception of ExceptionType1, where it will be captured.

If not, it will be transferred to the second catch block.

So, until the exception is caught by any catch or block.

Examples

This example shows how using multiple try / catch.

try
{
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException i)
{
   i.printStackTrace();
   return -1;
}catch(FileNotFoundException f) //Not valid!
{
   f.printStackTrace();
   return -1;
}

throws / throw Keywords:

If a method does not capture a checked exception, then the method must use the throws keyword to declare. throws keyword placed at the end of the method signature.

You can also use the keyword throw throw an exception, whether it is new or newly instantiated captured.

The following method declaration throws a RemoteException exception:

import java.io.*;
public class className
{
   public void deposit(double amount) throws RemoteException
   {
      // Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

A method can be declared to throw multiple exceptions, separated by a comma between multiple exceptions.

For example, the following method declaration throws RemoteException and InsufficientFundsException:

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

finally keyword

finally keyword is used to create the code blocks after the code block try to perform.

Whether or not an exception occurs, finally code block code will always be executed.

In the finally block, you can run clean up the aftermath of the nature of the type of ending statement.

finally block appears in the catch block Finally, the syntax is as follows:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }
 

Examples

 public class ExcepTest{

   public static void main(String args[]){
      int a[] = new int[2];
      try{
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      finally{
         a[0] = 6;
         System.out.println("First element value: " +a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

The above examples compiled results are as follows:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Note that the following matters:

• catch can not exist independently of the try.
• In the try / catch block is not added after finally mandatory requirements.
• Not after the try catch block neither did finally block.
• try, catch, finally can not add any code between blocks.

Statement custom exception

In Java, you can customize exception. The following points need to remember to write your own exception classes.

• All exceptions must be Throwable subclasses.
• If you want to write a checked exception class, you need to inherit Exception class.
• If you want to write a runtime exception class, you need to inherit RuntimeException class.

You can define your own exception class like this:

class MyException extends Exception{
}

Only inherit Exception class to create exception classes are checked exception classes.

The following InsufficientFundsException class is a user-defined exception class that inherits from Exception.

An exception class and any other classes, contains variables and methods.

Examples

// 文件名InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception
{
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   } 
   public double getAmount()
   {
      return amount;
   }
}

To demonstrate how to use our custom exception class,

In the following CheckingAccount class contains a withdraw () method throws an exception InsufficientFundsException.

// 文件名称 CheckingAccount.java
import java.io.*;

public class CheckingAccount
{
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
   public void deposit(double amount)
   {
      balance += amount;
   }
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   public double getBalance()
   {
      return balance;
   }
   public int getNumber()
   {
      return number;
   }
}

The following program demonstrates how to call BankDemo CheckingAccount class deposit () and withdraw () method.

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

Compile the above three files, and run the program BankDemo, get the results as follows:

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

General exception

It defines two types of exceptions and errors in Java.

• JVM (Java Virtual Machine) exception: exception thrown by the JVM or errors. For example: NullPointerException class, ArrayIndexOutOfBoundsException class, ClassCastException class.
• Program-level exception: API program by the program or thrown. For example class IllegalArgumentException, IllegalStateException class.