异常 Java

异常：

程序出现了不正常的情况。

1、
Throwable类是Java语言中所有错误和异常的超类。
两个子类的实例Error和异常通常用于表示出现异常情况。

一个Error是的子类Throwable表示严重的问题，合理的应用程序不应该试图捕获。

异常及其子类是Throwable的形式，表示合理应用程序可能想要捕获的条件。
异常类和不是RuntimeException的子类的任何子类都是检查异常 。 检查的异常需要在方法或构造函数的throws子句中声明，如果它们可以通过执行方法或构造函数抛出，并在方法或构造函数边界之外传播。
RuntimeException是在Java虚拟机的正常操作期间可以抛出的异常的超类。
RuntimeException及其子类是未经检查的异常 。（在编译期间不需要检查，出现问题后，需要我们回来修改代码）

2、JVM的默认处理方案
如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理
（1）把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
（2）程序停止执行

3、异常处理
如果程序出现异常，我们需要自己来处理，两种方案：try…catch…；throws

4、try…catch…：
格式：

	try{
		可能出现异常的代码;
    }catch(异常类名 变量名){
    	异常的处理代码;
    }

执行流程：
程序从try里面的代码开始执行。
出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统。
当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理。
执行完毕之后，程序还可以继续往下执行。

5、Throwable的成员方法：
public String getMessage()：返回此throwable的详细消息字符串
public String toString()：返回此可抛出的简短描述
public void printStackTrace()：把异常的错误信息输出在控制台

package learn;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try{
            int[] arr={1,2,3};
            System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException("xxx");
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            /*
            开始
            结束
            java.lang.ArrayIndexOutOfBoundsException: 3
	            at learn.TestDemo.method(TestDemo.java:12)
	            at learn.TestDemo.main(TestDemo.java:6)
             */
            //System.out.println(e.getMessage());//3
            //System.out.println(e.toString());//java.lang.ArrayIndexOutOfBoundsException: 3
        }
    }
}

6、编译时异常和运行时异常：
Java中异常分为：编译时异常和运行时异常，也被称为受检异常和非受检异常。
所有的RuntimeException类及其子类被称为运行时异常，其他异常都是编译时异常。
编译时异常：必须显示处理，否则程序会发生错误，无法通过编译。
运行时异常：无需显示处理，也可以和编译时异常一样处理。

7、异常处理：throws：
虽然我们可以通过try…catch…对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理。即有些异常我们处理不了，针对这种情况，Java提供了throws的处理方案。

格式：

	throws 异常类名;

注意：这个格式是跟在方法的括号后面的

代码一：

package learn;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //method();
        method2();
        System.out.println("结束");
    }
    //运行时异常
    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);//
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            /*
            开始
            结束
            java.lang.ArrayIndexOutOfBoundsException: 3
	            at learn.TestDemo.method(TestDemo.java:12)
	            at learn.TestDemo.main(TestDemo.java:6)
             */
        }
    }
        public static void method2() throws ArrayIndexOutOfBoundsException{
                int[] arr={1,2,3};
                System.out.println(arr[3]);
            /*
            开始
            Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	            at learn.TestDemo.method2(TestDemo.java:28)
	            at learn.TestDemo.main(TestDemo.java:7)
            */

            }
}

cf：throws处理异常并没有真正处理，仅仅是把异常抛出去，无法往下执行，没有输出"结束"。

代码二：

package learn;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //method();
        try {
            method2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
    //编译时异常
    public static void method() {
        try {
            String s="2021-11-11";
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf.parse(s);
            System.out.println(d);
        } catch (ParseException e) {
            e.printStackTrace();
            /*
            开始
            Thu Nov 11 00:00:00 CST 2021
            结束
            */
        }
    }
        public static void method2() throws ParseException {
            String s="2021-11-11";
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf.parse(s);
            System.out.println(d);
            /*
            开始
            Thu Nov 11 00:00:00 CST 2021
            结束
            */
            }
}

总结：
编译时异常必须进行处理，程序才能运行，两种方案：try…catch…或者throws，如果使用throws这种方案，将来谁调用谁处理。
运行时异常可以不处理，出现问题后，需要我们回来修改代码。

8、自定义异常：
我们的类继承自RuntimeException或者Exception，它就成为了异常体系的一员。

格式：

        public class 异常类名 extends Exception{
            无参构造
            带参构造
        }

代码：

package learn;

public class ScoreException extends Exception{
    public ScoreException(){}

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

package learn;

public class Teacher {
    public void checkScore(int score) throws ScoreException{//抛出异常类，因为此处为编译时异常，如果不处理，就无法通过编译。
        // 如果此处ScoreException继承自RuntimeException，则可用throws抛出，也可不用
        if(score<0||score>100){
            //throw new ScoreException();//使用的无参构造方法
            //throw无s，抛出异常对象，因为这个异常是我们自定义的，所以我们要手动去抛。而Java提供的，如果我们不抛，它会自动去抛
            throw new ScoreException("分数有误，分数应>=0且<=100");//使用的带参构造
        }else{
            System.out.println("分数正常");

        }
    }
}

package learn;

import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int score=sc.nextInt();

        Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

9、