java 捕获和抛出异常

捕获和抛出异常

java中有两种异常机制：1.捕获并处理异常：当运行环境得到一个异常对象时，将会沿着方法的调用栈逐层回溯，

寻找处理这些异常的代码，运行环境把当前异常对象交给这个方法进行处理，这一过程

称为捕获(catch)异常。

2.将方法中产生的异常抛出，如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，

声明抛出异常。

捕获并处理异常

try catch finally 语句

通常使用代码框架来进行异常的捕获与处理；

try{
    //可能出现的异常的代码
}catch(.....){
    //异常处理代码
}finally{
    //执行最终清理的句子
}

1.try选定捕获异常范围，代码块中的语句可能会生成异常对象并抛出。

2.catch每try代码块可以伴随一个或者多个catch语句用于处理try所产生的的异常事件，catch语句只需要一个形

式参数指明它所能捕获的异常类型，这个类是Throwable的子类，运行时try的异常对象传递给catch，如果try

产生的异常与某个catch语句处理的异常类型相匹配，则执行catch语句块。

3.finally语句块是否发生生异常都要执行，一般用于关闭文件或者释放其它系统资源。

异常抛出

1.如果在一个方法中生成了一个异常，但是这个方法并不确切地知道该如何对这异常事件进行处理，这时，

一个方法就应该声明抛出异常，使得异常对象可以从调用栈向后传播，直到有合适的方法捕获它为止。

2.声明异常：异常是在方法的声明中使用throws子句进行声明的

具体格式： *返回类型方法名() throws exceptionlist

带有throws子句的方法所抛出的异常有两种来源：1.一种是方法中调用了可能抛出的异常

2.另一种异常对象来源就是方法体中生成并抛出异常对象。

   package exception;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

try {//监控区域
            System.out.println(a / b);
        } catch (ArithmeticException e)//捕获异常  (catch（想要捕获的异常类型！）)
        {
            System.out.println("程序出现异常，变量b不能为0");
        } finally {//处理善后工作
            System.out.println("finally");//finally 可以不要finally，假设io，资源，关闭！
        }
        try {
            new Test().a();
        } catch (Throwable e) {
            System.out.println("程序出现异常，变量b不能为0");
        } finally {
            System.out.println("finally");
        }
        //  假设要捕获多个异常；从小到达！
        try {
            System.out.println(a / b);
        } catch (Error e) {
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Eception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }


    }

    public void a() {
        b();
    }

    public void b() {
        a();
    }
}

package exception;

public class Test2
{
    public static void main(String[] args)
    {
        int a=1;
        int b=0;
        //Ctrl+Alt+T
        try {
            System.out.println(a/b);
        } catch (Exception e) {
                                                      //System.exit(0);
            throw new RuntimeException(e);//打印错误的栈信息
        } finally {
        }
    }
}

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {//主动的抛出异常  throw   throws
            if (b == 0) {
                throw new ArithmeticException();//主动的抛出异常
               
            }
            System.out.println("a/b");
        } catch (Error e) {
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Eception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }
    }

package exception;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {//可以让代码继续执行
            new Test().test(a,b);
        } catch (ArithmeticException e) {
           e.printStackTrace();
        }
    }
     //假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException
{
    if (b == 0) {
        throw new ArithmeticException();//主动的抛出异常,一般在方法中使用

    }
    //System.out.println("a/b");

}
    }