处理异常方式try_catch_finally， throws，throw

如何处理 Exception 的异常：

抓抛模型:1.抓：异常的处理，有两种方式①try-catch-finally   ②throws+异常类型

2.抛：一旦执行过程中出现异常,会抛出一个异常类的对象(自动的抛出 vs  手动的抛出(throw+异常类对象))

异常处理方式一：try_catch_finally

package com.aff.excep;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;

/*
处理Exception的异常
java提供的异常处理的抓抛模型：
          1. "抛" 执行代码，出现异常，就会在异常的代码处生成一个对应异常的类的对象， 并将此对象抛出
                  一旦抛出此异常的对象， 那么程序就终止运行，此异常的对象抛给方法的调用者
          2. "抓" 抓住上一步抛出来的异常类的对象。
异常处理的方式：
          java提供了两种方式用来处理一个异常类的对象
          处理方式一：try{
                                   //可能出现异常的代码
                              }catch(Exception e1){
                                  //处理的方式1
                              }catch(Exception e2){
                                  // 处理的方式2
                              } finally{
                                  //一定执行的代码
                              }
注：1.try内生命的变量， 类似于局部变量。出了try{ }语句，就不能被调用
       2.finally是可选的。
       3.catch语句内部是对异常对象的处理
                             getMessage();    printStackTrace();
       4.可以有多个actch语句，try中抛出的异常类对象从上往下匹配catch中的异常类的类型，
          一旦满足，就执行catch中的代码，执行完，就跳出其后的多条catch语句
       5.如果异常处理了，其后面的代码可以执行了
       6.若catch 中多个异常类型是 "并列" 关系,谁上谁下都可以
         若catch中多个异常类型的 "包含" 关系,须将子类放在父类的上面，进行处理，否则报错
       7.finally 中存放的一定是会被执行的代码，不管try中，catch中是否有异常未被处理，以及是否有return
       8.try- catch是可以嵌套的 

对于运行时异常来说，可以不显式的进行处理，
对于编译时异常来说，必须要显式的进行处理

 */
public class TestException1 {
    @Test
    public void test6() {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File("heel.txt"));
            int b;
            while ((b = fis.read()) != -1) {
                System.out.println((char) b);
            }
        } catch (FileNotFoundException e1) {// e1相当于局部变量， 下面的exception也可以使用e1
            // System.out.println(e1.getMessage());
            System.out.println("找不到文件");
        } catch (IOException e1) {
            System.out.println(e1.getMessage());
        } finally {
            // 一定会执行的代码
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test2() {
        try {
            int[] i = new int[10];
            // System.out.println(i[10]);
            System.out.println(i[-10]);
        } catch (Exception e) {
            // e.printStackTrace();
            System.out.println("出现异常");
            // System.out.println(e.getMessage());
        } finally {
            // 一定会执行的代码
        }
    }
}

异常处理方式一：throws ，向上抛 最后用try-catch 解决

package com.aff.excep;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/*
 异常处理方式二：在方法的声明处，显示的抛出该异常对象的类型
 格式：如public  static void   method2() throws IOException{ }
           当在此方法内部出现异常的时候回抛出一个异常类的对象，抛给方法的调用者
           异常的对象可以逐层向上抛，直至main中，当然在向上抛的过程中，可以再通过try-catch-finally进行处理

 */
public class TestException2 {
    public static void main(String[] args) {
        try {
            method2();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public  static void   method2() throws IOException{
        method1();
    }

    public  static void method1() throws IOException {
        FileInputStream fis = new FileInputStream(new File("heel.txt"));
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
    }
}

手动的抛出异常：

package com.aff.excep;
//1.手动的抛出一个异常
//2.抛出的异常类型若是RuntimeException，可以不显示的处理
//若是一个Exception，必须要显式的处理
public class TestCircle {
    public static void main(String[] args) {
        Circle c1 = new Circle(2.1);
        Circle c2 = new Circle(2.1);
        try {
            System.out.println(c1.comparTo(c2));
            System.out.println(c1.comparTo(new String("AA")));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Circle {
    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle(double radius) {
        super();
        this.radius = radius;
    }

    // 比较两个圆的半径的大小
    public int comparTo(Object obj) throws Exception {
        if (this == obj) {
            return 0;
        } else if (obj instanceof Circle) {
            Circle c = (Circle) obj;
            if (this.radius > c.radius) {
                return 1;
            } else if (this.radius == c.radius) {
                return 0;
            } else {
                return -1;
            }
        } else {
            // return -2;
            //throw new RuntimeException("传入的类型有误");//运行时异常编译不显示错误
            throw new Exception("传入的类型有误");
        }
    }
}