Java之异常处理学习笔记

异常的概念

知识点：

Java的异常机制
Java异常类层次结构
Throwable类
String getMessage()、void printStackTrace()、String toString()
try、catch、 finally 、 throws、throw
自定义异常类

概念：

在程序运行时打断正常程序流程的任何不正常的情况称为错位或异常。

错误类型：

一般性的错误：
输入数据在保存到数组过程中引起超界、除数为零、输入数据不合法等
致命性的错误：
系统硬件故障、网络通讯中断等引起的无法恢复性错误

处理方式：

向用户通知错误
保存全部工作
让用户适当地退出程序

java.lang.Throwable 类是所有异常类的父类。

Java处理的异常大致分为3类：Error及其子类、RuntimeException及其他Exception类
Java对于不同的异常通常采取不同的策略
1. Error 意味着是很难恢复的严重错误，一般不由程序处理。
2. RuntimeException 意味着程序设计或实现问题，如：数据使用越界，算术运算异常（如除0运算），空指针异常即访问没有初始化的空指针等。对于这类异常，处理的策略是纠正错误。
3. 其他异常，通常是由环境因素引起的，例如文件不存在，无效URL等。这类异常通常是由用户的误操作引起的，可以在异常处理中处理，例如提示用户进行正确操作。

常见的异常：

异常	说明
RuntimeException	java.lang包中多数异常的父类
ArithmeticException	算术错误，如除以 0
ArrayIndexOutOfBoundsException	数组下标出界
ClassCastException	非法强制类型转换
NumberFormatException	字符串到数字格式非法转换
ArrayStoreExcepiton	数组元素赋值类型不兼容
IllegalArgumentException	调用方法的参数非法
NullPointerException	试图访问 null 对象引用

异常处理语法

异常处理具体有如下两种方式：
1. 捕获并处理异常。
2. 将方法中产生的异常抛出。

捕获并处理异常：

1. try catch finally 语句

try catch finally 语句捕获程序中产生的异常，然后针对不同的异常采用不同的处理程序进行处理。

基本格式：

    try//try块发现异常并抛出“有异常类产生的对象”
    {
        //一条或多条要检查的程序语句；
    }
    catch(异常类1 对象名)// catch块捕捉由try块抛出的异常，并做相应处理
    {
        //异常发生时的处理语句；
    }
    catch(异常类2 对象名)
    {
        //异常发生时的处理语句；
    }
    finally //finally块必须执行的语句，不管发生异常否
    {
        //执行最终处清理的语句
    }

try catch finally 语句中把可能产生异常的程序放入try{}语句块，然后在之后紧跟一个或多个catch语句块，每个catch块处理一种可能抛出的特定类型的异常。
finally 语句定义了一个程序块，放于try{},catch{}之后，不管程序有无异常都会执行。
注：try catch finally 语句中，catch语句块可以有一个或多个，finally语句块可以省略，但是try语句后至少要有一个catch语句或finally语句。

2. 针对多种异常的通用处理：

用catch语句进行异常处理时，可以使一个catch块捕获一种特种特定类型的异常，也可以定义多种类型的异常的通用catch块。
Java异常的层次结构：

    //Catch语句块处理Exception类及其所有子类类型的异常。
    try{

            }
            catch(Exception e){
                System.err.println("Exception caught: " + e.getMessage());
            }

例：

public class Helloworld {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i = 0;
        String greetings[]={"hello","hi","goodbye"};
        while(i<4){
            try{
                System.out.println(greetings[i++]);
            }
            catch(ArrayIndexOutOfBoundsException e){
                System.err.println("Caught ArrayIndexOutOfBoundsException:"+e.getMessage());
            }
        }
    }
}

异常类常用方法

查阅JDK帮助学习Throwable类
构建器
Throwable() ：构造一个无详细信息的新的 Throwable
Throwable(String message) ：用指定信息创建新的 Throwable
方法均继承自Throwable类
String getMessage() ：返回该 Throwable 对象的简短描述
String toString()：返回描述，包括详细信息
void printStackTrace() ：打印出异常发生的路径，及引起异常的方法调用的序列

抛出异常有两种方式：

将方法中产生的异常抛出：

调用该方法的程序将接收到所抛出的异常。
如果被抛出的异常在调用中未被处理，则该异常将被沿着方法的调用关系继续上抛，直到被处理。如果一个异常被返到main()方法，并且在main()方法中未被处理，则该异常将把程序非正常终止。
语法格式
[修饰符]返回类型 方法名(参数序列)throws异常类型1， [异常类型2，……]
{
方法体
}
调用此方法时必须使用try/catch语句来捕获

public class TestThrows{

    public void aaa(int a,int b) throws ArithmeticException{
          int c;
          c=a/b;
          System.out.println(a+"/"+b+"="+c);      
    }

    public static void main(String args[]){  
           try{
                TestThrows  test = new TestThrows();
                test.aaa(4,0);
           }
            catch(ArithmeticException e){
                System.out.println(e+" throwed");
           }
    }   
}

在程序中抛出异常：throw

触发异常：throw
语法格式： throw 异常对象;

int a = 4,b = 0;
        try{
            if(b == 0){
                 throw new ArithmeticException();
            }
            else
            {
                System.out.println(a + " / " + b +" = " + a/b);
            }
        }
        catch(ArithmeticException e){
            System.err.println(e + "throwed");
        }

其实：
ArithmeticException为系统内置的异常
在程序代码中抛出系统内置的异常并没有太大的意义。
通常从程序中抛出的是自己编写的异常类

请关注两点：
在程序中抛出异常时，一定要用到throw关键字
注意：抛出异常时，throw关键字所接收的是“由异常类所产生的对象”，因此throw语句必须使用new关键字来产生对象

自定义异常类

定义异常类：

1. 自定义的异常必须直接或间接继承Throwable类，通常从Exception类直接继承
2. 可扩展成员变量和方法

格式：

Class 异常类名 extends Exception
{
……
}
例：

public class SeverTimeOutException extends Exception{
    private String reason;
    private int port;
    public SeverTimeOutException(String reason,int port){
        this.reason = reason;
        this.port = port;
    }
    public String getReason(){
        return reason;
    }
    public int getPort(){
        return port;
    }
}

抛出自定义异常：

扩展Exception类来创建自定义的异常类。当实现自定义异常时使用throw和throws关键字
用户定义的异常同样要用try–catch捕获，由用户抛出 throw new MyException

例：

public void connectMe(String severName) throws SeverTimeOutException{
        int success;
        int portToConnect = 80;
        success = open(severName, portToConnect);
        if(success == -1){
            throw new SeverTimeOutException("Could not connect",80);
        }
    }

注意：
一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类