JAVA-异常机制

异常的概述和分类

异常的概述
异常就是Java程序在运行过程中出现的错误。
异常的继承体系
异常的基类: Throwable
严重问题: Error 错误，无法解决
非严重问题: Exception异常,属于一般性问题，我们可以解决，我们在写程序过程中需要处理的就是异常
编译时异常: 非RuntimeException发生在编译期间，你必须解决，不解决程序无法运行
运行时异常: RuntimeException发生在程序运行过程当中，你可以解决，也可以不解决

JVM默认处理异常

main函数收到这个问题时,有两种处理方式:
a:自己将该问题处理,然后继续运行
b:自己没有针对的处理方式,只有交给调用main的jvm来处理
jvm有一个默认的异常处理机制,就将该异常进行处理.
并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

public class MyTest2 {
    public static void main(String[] args) {
         int a=10;
        int b=0;
        //ArithmeticException
        //当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
        System.out.println(a/b);
        //运行期异常的默认处理方式：是抛给了JVM去处理，那么JVM的默认处理方式，是打印异常的堆栈信息，然后退出虚拟机。
       //Exception in thread "main" java.lang.ArithmeticException: / by zero
    }
}

try…catch的方式处理异常1

异常处理的两种方式
a:try…catch…finally
b:throws
try…catch处理异常的基本格式

 /*try {
  可能出现问题的代码 ;
 }catch(异常名 变量名){
  针对问题的处理 ;
 }finally{
  释放资源;
 } */
 public class MyTest {
    public static void main(String[] args) {
        Scanner scanner=null;
        try {
           // System.out.println(1/0);
            scanner= new Scanner(System.in);
            System.out.println("请输入第一个数");
            int a = scanner.nextInt();
            System.out.println("请输入第一个数");
            int b = scanner.nextInt();
            System.out.println(a / b);

        }catch (ArithmeticException e){
            //遇到以你捕获的该类的异常，就执行
            System.out.println("除数为0");
        } finally {
            //我们一般在finally里面喜欢做一些善后收尾工作，比如释放资源
            System.out.println("finally里面的代码，不管try 里面有没有遇到异常，都会 执行");
            if (scanner != null) {
                scanner.close(); //释放资源
            }
        }
    }
}

变形格式:

 /* try {
   可能出现问题的代码 ;
  }catch(异常名 变量名){
   针对问题的处理 ;
  }*/
  public class MyTest3 {
    public static void main(String[] args) {
        //我们自己处理运行期异常，使用关键字try{}catch()
        int a = 1;
        int b = 0;
        try {
            //try 里面 放的是，有可能会出现异常的代码，一旦出现异常，就会执行catch里面的代码
            //当然try里面没有遇到异常，那么catch里面的代码，就不执行
            System.out.println(a / 1);
        } catch (ArithmeticException e) {
            //处理异常的方式
            System.out.println("除数为0了");
        }
     }
}

注意事项:
a: try中的代码越少越好
b: catch中要做处理,哪怕是一条输出语句也可以.(不能将异常信息隐藏)

try…catch的方式处理异常2

/* try {
 可能出现问题的代码 ;
}catch(异常名1 变量名1){
 对异常的处理方式 ;
}catch (异常名2 变量名2){
  对异常的处理方式 ;
}....
 try {
 可能出现问题的代码 ;
}catch(异常名1 变量名1){
 对异常的处理方式 ;
}catch (异常名2 变量名2){
  对异常的处理方式 ;
}....*/
public class MyTest {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        int[] arr={2,3};
        arr=null;
        try {
            //try 里面放一些有可能会出现异常的代码，那么无谓的代码就不要往里面放
            System.out.println(arr.length);
            System.out.println(a / b);
            System.out.println(arr[3]);
            System.out.println("====================");
        //catch 可以并列写多个，捕获不同的异常
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组角标越界异常");
        }catch (ArithmeticException e){
            System.out.println("除数为0的异常");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("其他异常");
        }

//ctrl+H 可以看一个类的继承关系

    }
}

注意事项：
1:能明确的尽量明确，不要用大的来处理。
2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。

throws的方式处理异常

throws的方式处理异常
定义功能方法时，需要把出现的问题暴露出来让调用者去处理。
那么就通过throws在方法上标识。

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException{
       // 编译期异常:非  RuntimeException及其子类，发生在编译期间，必须处理，不处理，程序无运行
        //编译期的处理方式：一种抛给调用者，处理，谁调用谁处理，简称甩锅 throws
        //另外一种就是自己捕获处理
        Dog dog = new Dog();
        //编译期异常，我们自己不捕获处理，那么就抛给调用者，去处理
        dog.clone();
        //编译期异常的处理：alt+enter 使用万能纠错键，选择抛出，或者捕获
        try {
            hehe();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("========");
    }

    public static void hehe() throws ParseException{
        new SimpleDateFormat("yyyy-MM-dd").parse("2017:11-11");
    }
}

class Dog implements Cloneable{
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

throw的概述以及和throws的区别

throw的概述

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

throws和throw的区别

throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
这个异常对象可以是编译期异常对象,可以是运行期异常对象
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

自定义异常

 if(score > 100 || score < 0){
  
  // 抛出一个异常对象
  //注意 自定义异常类 提供有参数构造 
  throw new MyException("成绩不在有效的范围内(0~100)....") ;
  
 }else {
  System.out.println("成绩合法.....................");
 }

异常注意事项(针对编译期异常)
a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类，或者子类不抛出异常也是可以的。(父亲坏了,儿子不能比父亲更坏)
b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的。
c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

如何使用异常处理
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws

如果JDK没有提供对应的异常，需要自定义异常。