Java 异常处理

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如，代码中少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果用System.out.println(11/0)，那么因为用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

1.用户输入了非法数据

2.要打开的文件不存在

3.网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起，还有其它一些是因为物理错误引起的。

三种类型的异常：

1.检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。：

2.运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。：

3.错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

1.Exception类

所有的异常类都是 java.lang.Exception 类的子类，而Exception类是 Throwable 类的子类。Exception类有两个主要的子类：IOException类和 RuntimeException类。除了Exception类外，Throwable还有一个子类Error ，Error用来指示运行时环境发生的错误。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外

2.Java 内置异常类

Java 语言定义了一些异常类在 java.lang 标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

以下列举一些异常：

ArithmeticException
//当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。

ArrayIndexOutOfBoundsException
//用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。

ArrayStoreException
//试图将错误类型的对象存储到一个对象数组时抛出的异常。

ClassCastException
//当试图将对象强制转换为不是实例的子类时，抛出该异常。

IllegalArgumentException
//抛出的异常表明向方法传递了一个不合法或不正确的参数。

IllegalMonitorStateException
//抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。

IllegalStateException
//在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java环境或 Java应用程序没有处于请求操作所要求的适当状态下。

IllegalThreadStateException
//线程没有处于请求操作所要求的适当状态时抛出的异常。

IndexOutOfBoundsException
//指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。

NegativeArraySizeException
//如果应用程序试图创建大小为负的数组，则抛出该异常。

NullPointerException
//当应用程序试图在需要对象的地方使用 null 时，抛出该异常

NumberFormatException
//当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

SecurityException
//由安全管理器抛出的异常，指示存在安全侵犯。

StringIndexOutOfBoundsException 
//此异常由 String方法抛出，指示索引或者为负，或者超出字符串的大小。

UnsupportedOperationException
//当不支持请求的操作时，抛出该异常。

ClassNotFoundException
//应用程序试图加载类时，找不到相应的类，抛出该异常。

CloneNotSupportedException  
//当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现Cloneable接口时，抛出该异常。

IllegalAccessException
//拒绝访问一个类的时候，抛出该异常。

InstantiationException  
//当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。

InterruptedException
//一个线程被另一个线程中断，抛出该异常。

NoSuchFieldException    
//请求的变量不存在

NoSuchMethodException   
//请求的方法不存在

3.异常方法

public String getMessage()
//返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。

public Throwable getCause()
//返回一个Throwable 对象代表异常原因。

public String toString()
//使用getMessage()的结果返回类的串级名字。

public void printStackTrace()
//打印toString()结果和栈层次到System.err，即错误输出流。

public StackTraceElement [] getStackTrace()
//返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。

public Throwable fillInStackTrace()
//用当前的调用栈层次填充Throwable对象栈层次，添加到栈层次任何先前信息中。

4.捕获异常

使用 try/catch 关键字可以捕获异常,try/catch 代码块放在异常可能发生的地方,try/catch代码块中的代码称为保护代码.

public class JavaException {
    public static void main(String[] args) {
        try {
            int a[] = new int[2];
             System.out.println(a[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Exception:" + e);
        }
    }
}

多重捕获块

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

5.throws/throw

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

import java.io.*;
public class className {
   //声明抛出 RemoteException 和 InsufficientFundsException 两个异常
   public void withdraw(double amount) throws RemoteException,InsufficientFundsException {
      //直接抛出一个异常
      throw new RemoteException();
   }
}

6.finally

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

public class JavaException {
    public static void main(String[] args) {
        int arr[] = new int[2];
        try {
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("异常"+e);
        } finally {
            arr[1] = 10;
            System.out.println("finally" + arr[1]);
        }
    }
}

7.声明自定义异常

在 Java 中可以自定义异常。编写自己的异常类时需要记住下面的几点:

1.所有异常都必须是 Throwable 的子类

2.如果希望写一个检查性异常类，则需要继承 Exception 类

3.如果想写一个运行时异常类，那么需要继承 RuntimeException 类

class MyException extends Exception {

}

下面的程序演示了如何定义一个银行存取款的异常操作

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

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;
    }
}

public class JavaException {
    public static void main(String[] args) {
    
        CheckingAccount ca = new CheckingAccount(123456);
        System.out.println("存钱500...");
        ca.deposit(500);
        
        try {
            System.out.println("取钱100...");
            ca.withdraw(100);
            System.out.println("取钱1000...");
            ca.withdraw(1000);
        } catch (InsufficientFundsException e) {
            System.out.println("余额不足" + e.getAmount());
            e.printStackTrace();
        }
    }
}