java之异常处理

JAVA是采用面向对象的方式来处理异常的。处理过程：

1. 抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象提交给JRE。

2. 捕获异常：JRE得到该异常后，寻找相应的代码来处理该异常。JRE在方法的调用栈中查找，从生成异常的方法开始回溯，直到找到相应的异常处理代码为止。

大部分异常都有俩构造器

1. 带详细信息

2. 不带详细信息

异常分类

                    Throwable                    /       \                Errow      Exception                ↗         ↗       ↖            unchecked   checked   Runtime            Exception   Exception Exception                                    ↗                                unchecked                                Exception

Java 中定义了两类异常：

1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理，如果子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。C#中就没有使用这种异常机制。

2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是特殊的，它们不能通过client code来试图解决，所以称为Unchecked exception 。

Unchecked Exception:
a. 指的是程序的瑕疵或逻辑错误，并且在运行时无法恢复。
b. 包括Error与RuntimeException及其子类，如：OutOfMemoryError, UndeclaredThrowableException, IllegalArgumentException, IllegalMonitorStateException, NullPointerException, IllegalStateException, IndexOutOfBoundsException等。
c. 语法上不需要声明抛出异常。

Checked Exception:
a. 代表程序不能直接控制的无效外界情况（如用户输入，数据库问题，网络异常，文件丢失等）
b. 除了Error和RuntimeException及其子类之外，如：ClassNotFoundException, NamingException, ServletException, SQLException, IOException等。
c. 需要try catch处理或throws声明抛出异常。

Exception：

1．可以是可被控制(checked) 或不可控制的(unchecked)

2．表示一个由程序员导致的错误

3．应该在应用程序级被处理

Error：（不需要程序员处理，出现后解决方法：重启）

1．总是不可控制的(unchecked)

2．经常用来用于表示系统错误或低层资源的错误

3．如何可能的话，应该在系统级被捕捉

常见异常

1. ArithmeticException

例如：试图除以0

//解决方案if(b!=0){int i = 1/b;}else{System.out.println("不能用0做除数！！");}

2.NullPointerException

当程序访问一个空对象的成员变量或方法，访问一个空数组的成员时发生。怎么处理？

//  TestException te = null;TestException te = new TestException();if(te!=null){te.test1(2);}

3.ClassCastException
不可以强制转型

//解决方案void test2(Object obj){if(obj instanceof Man){Man man = (Man) obj;    }}

4.ArrayIndexOutOfBoundsException
访问的元素下标超过数组长度

//解决方案int[] a = {1,2,3};int idx = 3;if(idx<=a.length-1){System.out.println(a[idx]);}

5.NumberFormatException

数字格式异常！

//解决方案String str = "1234abcf"; Integer i = new Integer(str);//  Integer i2 = Integer.parseInt(str);

异常处理方法

一，try catch

try块
try语句指定了一段代码，该段代码就是一次捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该段中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理

一个try语句必须带有至少一个catch语句块或一个finally语句块 。。

注：当异常处理的代码执行结束以后，是不会回到try语句去执行尚未执行的代码。

catch块
a) 每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

b) 常用方法：

toString ( )方法，显示异常的类名和产生异常的原因

getMessage( ) 方法，只显示产生异常的原因，但不显示类名。

printStackTrace( ) 方法，用来跟踪异常事件发生时堆栈的内容。

这些方法均继承自Throwable类

c) Catch捕获异常时的捕获顺序：

如果异常类之间有继承关系，在顺序安排上需注意。越是顶层的类，越放在下面。再不然就直接把多余的catch省略掉。

finally块
有些语句，不管是否发生了异常，都必须要执行，那么就可以把这样的语句放到finally语句块中。

通常在finally中关闭程序块已打开的资源，比如：文件流、释放数据库连接等。

//案例：public class TestException {    public static void main(String[] args) {        FileReader reader = null;        try {            reader = new FileReader("d:/a.txt");            char temp = (char) reader.read();            System.out.println("读出的内容：" + temp);        } catch (FileNotFoundException e) {            System.out.println("文件没有找到！！");            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();            System.out.println("文件读取错误！");        } finally {            System.out.println(" 不管有没有异常，我肯定会被执行！");            try {                reader.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

try, catch,finally ,return 执行顺序

1． 执行try，catch ， 给返回值赋值

2． 执行finally

3． return

public class TestException {    public static void main(String[] args) {        String str = new TestException().openFile();        System.out.println(str);    }    String openFile() {        try {            System.out.println("aaa");            FileInputStream fis = new FileInputStream("d:/a.txt");            int a = fis.read();            System.out.println("bbb");            return "step1";        } catch (FileNotFoundException e) {//不可以与IOException的catch语句交换位置，因为IOException是FileNotFoundException的父类，所以如果IOException放在前面，FileNotFoundException的异常会先在IOException处处理，就不能确定出现异常是在什么位置。所以位于越顶层的父类应该放在最下面。            System.out.println("catching!");            e.printStackTrace();            return "step2";// 先确定返回值，并不会直接结束运行。        } catch (IOException e) {            e.printStackTrace();            return "step3";        } finally {            System.out.println("finally!");            // return "fff";不要在finally中使用return.不然会把前面的return给覆盖掉        }    }}

创建try-catch-finally代码快捷键
选择代码右击—> surround with —> try catch

二，声明异常

当Checked Exception产生时，不一定立刻处理它，可以再把异常Throws出去。

在方法中使用try-chatch-finally由这个方法处理异常。在一些情况下，当前方法并不需要处理发生的异常，而是向上传递给调用它的方法处理。

如果一个方法中可能产生某种异常，但是并不能确定如何处理这种异常，则应根据异常规范在方法的首部声明该方法可能抛出的异常。

如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间以逗号隔开。

例子：public class FileTest {    public static void main(String[] args) {        try {            readFile("d:/a.txt");        } catch (FileNotFoundException e) {            System.out.println("所需要的文件不存在！");            e.printStackTrace();        } catch (IOException e) {            System.out.println("文件读写出错误！");            e.printStackTrace();        }    }    public static void readFile(String fileName) throws IOException {        FileReader in = new FileReader(fileName);        try {            int tem = 0;            tem = in.read();            while (tem != -1) {                System.out.println((char) tem);                tem = in.read();            }        } finally {            in.close();        }    }}

方法中声明异常原则

子类声明的异常范围不可以超过父类

1.父类没有声明异常，子类也不能声明。
2.不可抛出原有方法抛出异常类的父类或者上层类。
3.抛出的异常类型的数目不可以比原有的方法抛出的还多（不是指个数）

三，手动抛出异常，throw

Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要手工创建并抛出。

在捕获一个异常前，必须有一段代码先生成异常对象并把它抛出。这个过程我们可以手工做，也可以由JRE来实现，但是他们调用的都是throw子句。

对于一个已经存在的异常类，抛出该类异常对象过程如下：

找到一个合适的异常类。

创建一个该类的对象。

将对象抛出

File f = new File("c:/tt.txt");    if (!f.exists())  {        try {        throw new FileNotFoundException("File can't be found!");        } catch (FileNotFoundException e) {        e.printStackTrace();    }}

四， 自定义异常

在程序中，可能会遇到任何标准异常类都没有充分的描述清楚的问题，这种情况下可以创建自己的异常类

从Exception类或者它的子类派生一个子类即可

习惯上，定义的类应该包含2个构造器：一个是默认的构造器，另一个是带有详细信息的构造器

class  IllegalAgeException   extends   Exception {public IllegalAgeException() {}public IllegalAgeException(String  msg) {super(msg);}}class Person {private String name;private int age;public void setName(String name) {this.name = name;}public void setAge(int age) {if (age < 0)throw new IllegalAgeException("人的年龄不应该为负数");this.age = age;}public String toString() {return "name is " + name + " and age is " + age;}} public class MyExceptionTest {public static void main(String[] args) {Person p = new Person();try {p.setName("Lincoln");p.setAge(-1);} catch (IllegalAgeException e) {e.printStackTrace();System.exit(-1);}System.out.println(p);}}

使用异常机制建议

1. 要避免使用异常处理代替错误处理，这样会降低程序的清晰性，并且效率低下。

   1. 处理异常不可以代替简单测试— 只在异常情况下使用异常机制

   2. 不要进行小粒度的异常处理—应该将整个任务包装在一个Try语句块中

   3. 异常往往在高层处理（高层即调用你的人）