Java进阶篇之异常处理

Java异常的处理

1.异常的概念

        异常在我们的编写代码的过程中无处不在。那么什么是异常呢？异常通俗的说就是程序错误，比如我们每次代码的结束要用分号“;”，如果这个分号的中文的分号，那么就会报错，只能是英文下的分号；又或者在对象未创建之前使用对象，那么会报错：NullPointerException 意为空指针异常。异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

2.异常的分类

        异常，其实也是有分类的，大体上可分错误、检查时异常、运行的异常：
（1）错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
（2）检查时异常：该异常一般是在编译时发生，在编译时期被编译器检查到而发生的异常，这种异常是可以避免的。
（3）运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

3.Exception类的层次

        所有的异常和错误都是来自Throwable 类，这个类下面有两个类，就是异常（Exception）和错误（Error）。Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。Error 用来指示运行时环境发生的错误。例如，JVM 内存溢出。一般地，程序不会从错误中恢复。
    而异常下面也有两个子类，分别是：**IOException 类(检查异常)和 RuntimeException 类(运行时异常)。**下面是异常分析图：

4.捕获异常

    我们平时写代码的时候肯定发现一个问题，如果出现的异常，那么无论后面是否还有代码，都会一顿爆红。那么异常是否可以解决的呢？对的，异常看到是可以解决的，异常是可以捕获的，把捕抓到的异常进行处理，这样不就可以解决异常问题了。但是如何捕获呢？先不急，我们先看一下下面的代码：

public class DeLight{
	public static void main(String[] args) {
			System.out.println("开始...");
			int a =10;
			System.out.println(a /0);
			System.out.println("结束...");
			
		}
}

运行结果：

• 看上述运行结果可知道这里报了个异常，异常叫：ArithmeticException 算术异常，报错提示除数不能为0，而且后面的代码也无法运行了，那么回到刚才的话题，捕获异常，那么如何捕获呢？捕获的玩法请看下面代码：

public class DeLight{
	public static void main(String[] args) {
		System.out.println("开始...");
		int a =10;
		try {
			System.out.println(a / 0);	
		}catch(ArithmeticException e) {
			System.out.println("Exception thrown  :" + e);
		}
		System.out.println("结束...");	
	}
}

运行结果：

-请看上述运行结束，后面的代码已经可以正常运行了。那么如何做到的呢？在刚才的代码里是否看到两个关键字try/catch,没错就是这两个家伙捕获了异常，而后面的代码就可以正常运行了。那么捕获异常的语法如何的呢？请看代码语法：

try
{
   // 程序代码
}catch(ExceptionName e)
{
   //Catch 块 填写如何处理异常
}

• 捕获异常正如上述所示，try里面的代码是放有可能出现异常的，比如上面的"a / 0"是会出现ArithmeticException异常的，而catch里面的代码块是处理异常的，比如上面的让其输出捕获到是异常是什么。对了，还有括号里面的参数，ExceptionName顾名思义就是异常的类型，捕获的是什么异常，e就是形参了，(这里有个小知识，有时候可能忘记了这是什么异常，所有一般写成Exception是可以的)。

5.异常的多重捕获

    我们已经知道如何捕获异常了，try代码里就是编写有可能发生的异常，那么是否考虑过这个问题：try语句里出现多个异常，这如何解决呢？这就需要多重捕获。代码格式如下：

try{
   // 可能出现异常程序代码
}catch(异常类型1 异常的变量名1){
  // 处理异常程序代码1
}catch(异常类型2 异常的变量名2){
  // 处理异常程序代码2
}catch(异常类型3 异常的变量名3){
  // 处理异常程序代码3
}
.......

• 看上述代码，简单的说就是try后面添加多个catch语句，在什么情况会出现这种情况呢，比如流里，看下面代码：

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

• 上述代码创建了一个文本流，然后进行读取，而读取的过程中有可能发生两个异常：FileNotFoundException和IOException，这就需要需要多重捕获了。

6.异常的声明与抛出

**    如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。**下面来一个例子就明白如何操作了：

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

• 上述使用了throws关键字声明要抛出的异常RemoteException,而使用throw是创建异常对象后抛出。值得注意的是throws的是可以抛出(声明)多个异常的。一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

7.finally关键字

    finally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。代码语法是把finally关键字放到catch的后面，如下：

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

• 需要注意的是，finally只能由一个，而且是在catch的后面，而且无论有没有异常发生，都会执行该代码。比如下面的代码：
      有异常的代码：

public class DeLight{
	public static void main(String[] args) {
		System.out.println("开始...");
		int a =10;
		try {
			System.out.println(a / 0);
		}catch(Exception e) {
			System.err.println("除数不为零");
		}finally {
			System.out.println("finally...");
		}
		System.out.println("结束...");
	}
}

• 运行效果：
  
• 无异常的代码：

public class DeLight{
	public static void main(String[] args) {
		System.out.println("开始...");
		int a =10;
		try {
			System.out.println(a / 2);
		}catch(Exception e) {
			System.err.println("除数不为零");
		}finally {
			System.out.println("finally...");
		}
		System.out.println("结束...");
	}
}

• 运行结果：
  

8.自定义异常

• 在有些时候，需要给用户或给程序做些警告，那么我们需要自定义异常。编写自己的异常类时需要记住下面的几点：
  （1）所有异常都必须是 Throwable 的子类。
  （2）如果希望写一个检查性异常类，则需要继承 Exception 类。
  （3）如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
• 定义异常的语法如下：

class MyException extends Exception{}

只继承Exception 类来创建的异常类是检查性异常类。下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。一个异常类和其它任何类一样，包含有变量和方法。

• 实例：一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作：

// 文件名InsufficientFundsException.java
import java.io.*;
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception{
  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  	private double amount;
 	public InsufficientFundsException(double amount){
    	this.amount = amount;
  } 
  public double getAmount(){
    return amount;
  }
}

为了展示如何使用我们自定义的异常类，在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常：

// 文件名称 CheckingAccount.java
import java.io.*;
//此类模拟银行账户
public class CheckingAccount{
  //balance为余额，number为卡号
   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;
   }
}

下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法：

//文件名称 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();
      	}
    }
}

运行程序 BankDemo，得到结果如下所示：

9.小结

    以上内容就是Java异常的基本知识。下面有几个异常的注意事项：
（1）catch 不能独立于 try 存在。
（2）在 try/catch 后面添加 finally 块并非强制性要求的。
（3）try 代码后不能既没 catch 块也没 finally 块，最起码要有1个catch块
（4）try, catch, finally 块之间不能添加任何代码。