JAVA-异常

1. 什么是异常

异常指程序运行中出现的不期而至的各种状况。异常发生在程序运行期间，它影响了正常的程序执行流程。

2. 异常的体系结构

JAVA把异常作为对象处理，并定义了一个基类java.lang.Throwable作为异常的超类。

3. 异常分类

异常可分为两大类Error,Exception

• Error：为严重问题，与代码的编写者无关，不需要处理。当出现Error时，JAVA虚拟机（JVM）会选择线程终止。
• Exception：异常类，表示程序本身可以处理的问题。
  可分为：
  Runtime Exception（运行时异常/非受检查异常）：无需显示处理，也可以和编译时异常一样处理；
  其他异常（编译时异常/受检查异常）：必须显示处理，否则程序就会发生错误，无法通过编译。

4. 异常处理机制

• 捕获异常
  关键字：try、catch、finally

	try{//try监控区域
            System.out.println(a/b);
    }catch (ArithmeticException e){//catch(想要捕获的异常类型) 捕获异常
            System.out.println("程序出现异常，除数b不能为0");
    }finally {//处理善后工作
            //无论程序是否出现异常，都会执行finnaly
            System.out.println("finally");
    }

		//可以写多个catch，但只会生效一个，所以捕获的异常类型：从小到大，例如从error->Throwable
        try{
            new Test01().a();
        }catch (Error e){
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable e){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }

• 抛出异常
  关键字：throw、throws
  throw、throws的区别：
  throws：
  （1）用在方法声明后： throws+异常名称；
  （2）表示抛出异常，由该方法的调用者来处理；
  （3）表示出现异常的一种可能性，并不一定会发生这些异常。
  throw：
  （1）用在方法体内，跟的是异常对象名；
  （2）表示抛出异常，由方法体内的语句处理；
  （3）执行throw一定抛出了某种异常。

public class Test03 {
    public static void main(String[] args) {
        //捕获异常
        try {
            new Test03().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
    //throws异常
    //虽然我们通过try...catch...可以处理异常，但不是所有的情况我们都有权限进行异常处理
    //当处理不了这个异常，就在方法上throws抛出异常，但是并没有对异常进行处理，
    // 还需要在main方法内，做捕获
    public void test(int a, int b) throws ArithmeticException{

        if(b == 0){//throw
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
    }
}

5. Throwable的成员方法

public String getMessage(); //返回此Throwable的详细消息字符串
public String toString(); //返回此可抛出的简短描述
public void printStackTrace();//将异常的错误信息输出在控制台

 	try {
            System.out.println(a/b);//当出现异常时，会实例化new Exception("/by zero");
        } catch (Exception e) {//e为实例化对象
            //Throwable的成员方法
            
            //public String getMessage();返回此Throwable的详细消息字符串
            System.out.println(e.getMessage());/// by zero

            //public String toString();返回此可抛出的简短描述
            System.out.println(e.toString());//java.lang.ArithmeticException: / by zero

            //public void printStackTrace();将异常的错误信息输出在控制台
            //输出的信息最全
            e.printStackTrace();//打印错误的栈信息
            // java.lang.ArithmeticException: / by zero
            // at exception.demo01.Test02.main(Test02.java:10)
        } finally {
        	
        }
        System.out.println("结束");

6. 自定义异常

JAVA内置的异常可以描述编程时出现的大部分异常，在此之外，用户可以自定义异常。用户自定义的异常，只需要继承extends Exception即可。
使用自定义异常的步骤：
（1）常见自定义异常；
（2）在方法中通过throw关键字手动抛出异常对象；
（3）如果在当前抛出异常的方法中处理异常，可用try{...}catch{...}捕获并处理；否则在方法的声明处通过throws指明抛出给方法调用者的异常，继续进行下一步操作；
（4）在出现异常的方法的调用者中捕获并处理异常。

自定义异常

public class MyException02 extends Exception{

    public MyException02() {//无参构造
    }

    public MyException02(String message) {//有参构造
        super(message);//父类
    }
}

Test02类

public class Test02 {
    //方法
    public void checkScore(int score) throws MyException02{
    
        if(score < 0 || score >100){
            //手动抛出异常对象new MyException02()
            //throw在方法体内部抛出异常对象名
            //throw new MyException02();//无参构造方法
            throw new MyException02("分数应该在0-100之间");//有参构造方法

        }else{
            System.out.println("分数正常");
        }
    }
}

mian()

	public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入（0-100）的分数：");
        int score = scanner.nextInt();

        //创建对象
        Test02 t2 = new Test02();
        //存在编译异常，main方法内捕获
        try {
            t2.checkScore(score);
        } catch (MyException02 myException02) {
            myException02.printStackTrace();
        }

    }