Day10.异常

目录

Error和Exception

什么是异常

异常分类

异常体系结构

Error

Exception

package com.exception;

public class Demo01 {
    public static void main(String[] args) {
//        System.out.println() //java: 需要';'
//        System.out.println(11/0); // by zero
/*        new Demo01().a(); //匿名内部类调用方法，StackOverflowError*/
    }
/*    public void a(){
        b();
    }
    public void b(){
        a();
    }*/
}

捕获和抛出异常

package com.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) { //ArithmeticException
//            System.exit(0); //可用来手动停止程序
            e.printStackTrace(); //打印错误的栈信息
        } finally {
        }
    }
}


package com.exception;

public class Test {
    public static void main(String[] args) {
    /*  int a = 1;
        int b = 0;
*/
/*        //try与catch必须连着使用的，可以不要finally，
        //finally用来：IO流，资源相关东西，Scanner等异常，无论如何需要把这些程序关闭，可以放在它里面
        try { //try监控区域：只要在这个大括号里面的代码出现异常，它就可以捕获的到
            System.out.println(a/b); //ArithmeticException: / by zero
        }catch (ArithmeticException e){ //catch(想要捕获的异常类型，最高的为Throwable)：捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally { //finally：处理善后工作，即无论出不出异常，finally里的话终究会被执行
            System.out.println("finally");
        }*/

/*        try {
            new Test().a(); //StackOverflowError
        }catch (Throwable*//*//*Error/Exception*//* e){
            System.out.println("出现异常");
        }finally {
            System.out.println("finally");
        }*/


        //捕获的异常有范围大小之分要把最大范围的放在最后：Throwable>Exception>Error
        //假设要捕获多个异常：要从小到大！
/*        try {
            if (b==0){ //throw   throws
                throw new ArithmeticException(); //主动的抛出异常：它什么都没有做，所以抛出异常一般在方法里去用
            }
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");// Exception
        }catch (Throwable e){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }*/

        //主动的抛出异常：它什么都没有做，所以抛出异常一般在方法里，假设方法报错，如下
//        new Test().test(1,0); //有 System.out.println(a/b);时，结果为ArithmeticException
//        new Test().test(1,0);//没有 System.out.println(a/b);时，结果仍为ArithmeticException


        //在方法上抛出异常，正常情况下需要把它捕获，throws：new Test().test(1,0);Ctrl + Alt + T
        try {
            new Test().test1(1,0); //算数异常属于运行时异常，正常情况下它不需要程序去抛出，它自己就会抛出
                                       //如果不用try...catch...的话，它遇到这种错误的时候，直接程序就停止了
                                       //但假设用了try...catch...后，程序会依旧往下执行
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }

    public void test(int a,int b){
        if (b==0){ //throw   throws
            throw new ArithmeticException(); //主动的抛出异常：它什么都没有做，所以抛出异常一般在方法里去用
        }
//        System.out.println(a/b);
    }
    
    //假设这个方法中处理不了这个异常，需要在方法上抛出异常，正常情况下，在外边调用这个方法时，需要把调用语句先捕获
    //主动在方法里面抛出异常是throw，在方法上抛出异常是throws
    public void test1(int a,int b)throws ArithmeticException{
        if (b==0){ //throw   throws
            throw new ArithmeticException(); //主动的抛出异常：它什么都没有做，所以抛出异常一般在方法里去用
        }
    }

}

自定义异常

package com.exception.demo02;

//自定义的异常类
public class MyException extends Exception{
    //假设传递数字>10，抛出一个异常
    private int detail; //用于接收数字

    //用于判断异常
    public MyException(int a) { //构造方法：Alt+Insert --> Construction-->Exception()
       this.detail = a;
    }

    //toString方法：异常的打印信息 Alt+Insert --> toString()
    @Override
    public String toString() {
        return "MyException{" + detail + '}';
    }
}

package com.exception.demo02;

//测试类
public class Test {
    //可能会存在异常的方法

    //调用下面这个方法可能会抛出一个异常，要去把它捕获回来
    static void test(int a) throws MyException { //测试的方法写法一  法二：在外面抛出异常，让调用test方法的人来捕获异常

        System.out.println("传递的参数为："+ a);

        if (a>10){ //假设 a>10，那么就抛出异常
            throw new MyException(a); //抛出
        }

        System.out.println("OK");
    }
/*    static void test(int a){ //测试的方法写法二
        if (a>10){ //假设 a>10，那么就抛出异常
            try {    //法一：在方法里面捕获异常，要么在方法里面捕获，要么在外面抛出异常
                throw new MyException(a);
            } catch (MyException e) {
                e.printStackTrace();
            }
        }
    }*/
public static void main(String[] args) {
    try {
        test(11);
    } catch (MyException e) { //此时捕获的是自定义的 MyException
        //增加一些处理异常的代码块
//        e.printStackTrace(); //打印出一些信息，e其实就是一些消息，可以不要该句，把消息输出一下
        System.out.println("MyException=>"+e);
    }
}

}

自定义异常类核心：
1.自己写一个异常类来继承Exception
2.这个类里面添加一些可能出现异常的问题
3.把这个异常消息打印出来，别人只要抛出了这个异常，我们把它捕获到，打印这个异常信息，即可得到最终的结果了

异常实际应用中的经验总结