Java小记——异常机制

目录

运行期异常

编译期异常

throw 

---

Erro 错误,严重性问题,你无法去捕获处理 比如内存溢出了

Exception 一般性问题,一般我们可以自己去捕获处理

编译期异常：发生在编译期间，非RuntimeException及其子类，必须解决，

运行期异常：RuntimeException及其子类 发生在运行期间，可以解决也可以不解决

运行期异常

//运行期异常：发生在运行期间，RuntimeException及其子类都是运行期异常，可以解决也可以不解决

        int a = 1;
        int b = 0;
        System.out.println(a / b);

        //运行期异常,如果你自己没有捕获处理,那是交由JVM,来进行默认处理.
        //JVM默认处理异常的方式，是打印异常的堆栈信息，然后退出JVM
        //很显然，JVM 默认处理异常的方式不够友好，如果想要更加友好，我们可以自己捕获异常去处理。


        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");  //执行不了

 处理异常

        int a = 1;
        int b = 0;
        try {
            //他里面放的是有可能会出现问题的代码
            System.out.println(a / 0);
        } catch (ArithmeticException e) { //ArithmeticException你要捕获的何种异常。
            //处理异常的逻辑，必须写，哪怕就是以后输出语句，不要空处理
            System.out.println("除数为0了");
        }
        //我们自己如何来处理运行期异常
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码"); 

           //除数为0了
            下面的代码
            下面的代码
            下面的代码
 

        int a = 1;
        int b = 0;
        int[] arr = {1, 2};
        try {
            System.out.println(a / b); //捕获住这个
            System.out.println(arr[3]); //就不再执行这个
        } catch (ArithmeticException e) {
            System.out.println("除数为0");
            e.printStackTrace(); //打印详细的堆栈信息
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("角标越界了");
            e.printStackTrace(); //打印详细的堆栈信息
        } catch (Exception e) {
            System.out.println("发生异常了");
            e.printStackTrace(); //打印详细的堆栈信息
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");



除数为0
下面的代码
下面的代码
下面的代码
java.lang.ArithmeticException: / by zero
	at org.slxy.demo.Demo01.MyTest.main(MyTest.java:11)
     

编译期异常

编译期异常：发生在编译期间，非RuntimeException及其子类

编译期异常，必须解决，不解决程序无法执行。

编译期异常处理方式：

1.向上抛出，抛给调用者，谁调用，谁处理，俗称甩锅。

2.自己try 捕获处理

try {
            MyDateUtils.test();
        } catch (ParseException e) {
            e.printStackTrace();
        }

finally {
            //一般有些善后工作，需要做，就可以放到finallys
            System.out.println("finally里面的代码，就是不管你有没有发生异常，都会执行");
        }

finally的作用:    用于释放资源

throw 

在方法内部进行抛出

public class MyTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数");
        int b = sc.nextInt();
        int r = chufa(a, b);
        System.out.println(r);


    }

    private static int chufa(int a, int b) {
        if (b == 0) {
            //在方法内部进行异常的抛出
            throw new ArithmeticException("除数为0");
        } else {
            return a / b;
        }
    }
}

自定义异常

//自定义的异常类，纳入到Java异常体系
public class ScoreException extends RuntimeException {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}


public class MyTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入你的成绩 0---100");
        int score = sc.nextInt();
        int cj = inputScore(score);
        System.out.println(cj);
    }

    private static int inputScore(int score) {
        if (score >= 0 && score <= 100) {
            return score;
        } else {
            throw new ScoreException("成绩不合法");
        }
    }
}

1.子类在重写父类方法时，父类方法没有抛出异常，子类不能抛出异常

2.父类方法有抛出异常，子类在重写父类方法时可以抛出和父类一样的异常，也可以不抛出

3.父类方法有抛出异常，子类在重写父类方法时可以抛出异常，但是异常不能比父类大