六、java 异常处理

一、JAVA异常的体系结构
 　　① Error:Java虚拟机无法解决的严重问题；一般不编写正对性的代码处理;
 　　② Exception:其他因为编程错误或偶然的外在因素导致的一般性问题;可以进行异常处理;处理完后不影响程序的运行；

　a.Exception又可以分为运行时异常和编译时异常；

　①编译时异常（check）：编译报错，要求必须处理，否则编译不通过；例如IOException、ClassNotFoundException

　②运行时异常（unchecked  RuntimExceprion）：一般不处理；例如：NullPointerExcepion（空指针异常），ArrayIndexOutOfBoundsException（数组越界异常），ClassCastExcetption（类转换异常），NumberFormateException...

二、异常处理的两种方式：

　　①不直接处理，往调用层抛出异常 throw + 异常类型；

　　②处理异常：try{}catch(){}finally{}

一下为异常处理的throw的方式：抛出异常，单元测试会报相应的NumberFormatException异常，无法执行到抛出异常后的语句；

    @Test
    public void testx() {
            String str = "abc";
            int num = Integer.parseInt(str);
            System.out.println("hello -1");
            throw new NumberFormatException();
            //System.out.println("hello -2");
    }

一下为异常处理的try catch的方式：单元测试通过，并且执行了System.out.println("hello -2");

    @Test
    public void test1() {
        String str = "abc";
        try {
            
            int num = Integer.parseInt(str);
            System.out.println("hello -1");
        }catch(NumberFormatException e) {//如果NumberFormatException换成时 NullPointerException则还是抛出异常
            System.out.println("出现数值转换异常了。。。。");
            String mes = e.getMessage();
            System.out.println(mes);//常用异常处理方式1
            e.printStackTrace();//常用异常处理方式2
            
        }
        System.out.println("hello -2");
    }

 三、过程：

　　过程一、“抛”；程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常的对象；并将此对象抛出；
 一旦抛出异常，其后面的代码不再执行；
　　关于异常对象的产生，1，系统生成 的，2.手动生成一个异常对象并且抛出；throw;
　　过程二：“抓”：可以理解为异常处理方式：

try catch finally的使用：
          try{
              //可能出现异常的代码
              }catch(异常类型1 变量名){
                     //处理异常方式1
              }catch(异常类型2 变量名){
                     //处理异常方式2
              }catch(异常类型3 变量名){
                     //处理异常方式3
              }
          ........
         finally{
             //一定会执行的代码
  }
  说明：
  1.finaly 是可选的
  2。使用try将肯出现的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，
       根据此对象的类型，去catch中进行匹配
  3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理，一旦处理完成就跳出try-catch结构（在没有finally的情况），
 继续执行后面的代码；
  4.catch中的异常类型如果没有子父类关系，则谁声明在上面，谁声明在下，无所谓，
      catch中的异常类型如果满足子父类关系，则要求子类在上，父类在下，否则报错；
  5.常用的异常处理方式 a.String getMessage() ;b printStackTrace();
  6.在try中声明的变量，出了try结构就不能调用；
  7.try catch finally 结构可以嵌套

例如：

@Test
    public void test2() {
        int a= 10;
        int b = 0;
        try {
            System.out.println(a / b); 
        } catch(ArithmeticException e){
            e.printStackTrace();
        }finally {
            System.out.println("finally~~~");
            // : handle finally clause
        }
    }

该程序 Junit通过，控制台打印异常和finally~~~；因为程序执行到 System.out.println(a / b); b=0所以 出现了错误，生成ArithmeticException对象，与catch中的异常进行匹配，匹配上后，进行异常处理，处理完成，执行finally中的代码；

    @Test
    public void test3() {

        Day16ErrorAndExceptionDiscriable6 tt = new Day16ErrorAndExceptionDiscriable6();
        
        System.out.println(tt.finallyTest());
    }

public int finallyTest() {
    try {
        int[] arr = new int[10];
        //System.out.println(arr[10]); 打开或者关闭，return都是3； 3之前是inally~~~
        return 0;
    } catch(ArrayIndexOutOfBoundsException e){
        e.printStackTrace();
        return 1;
    }finally {
        System.out.println("finally~~~");
        return 3;
        // : handle finally clause
    }
}

必须要处理的异常：如若需要调用时，必须要处理异常，或者是再往上抛出异常；

public void method() throws FileNotFoundException,IOException{
    File file = new File("hello.txt");
    FileInputStream fis = null;
    fis = new FileInputStream(file);
    int data = fis.read();
    while(data != -1) {
        data = fis.read();
    }
    fis.close();
}

public void method2() throws FileNotFoundException,IOException{
            method();
}

@Test
    public void test4() {
        File file = new File("hello.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            int data = fis.read();
            while(data != -1) {
                data = fis.read();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        
    }

体会：

　　try catch finally真正把异常处理掉，
　　throws 的方式只是将异常抛给了方法的调用者，并没有真正的处理掉异常

 开发中，如何选择try catch finally OR throws?
  1.如果父类中被重写的方法没有throws，则子类重写的方法也不能throws，意味着如果子类重写的方法有异常，必须用try catch finally；
 2.执行的方法A中，先后又调用了另外的几个方法，这几个方法是递进的关系执行的，建议这几个方法使用throws的翻翻，而执行的方法A可以考虑使用try catch finally；

 四、如何自定义异常
 1.继承于现有的异常体系RuntionExceptioin  Exception
  2.提供全局常量：serialVersionUID；表示类是否是同一个类

class MyException extends RuntimeException{
    static final long serialVersionUID = 1111111111111111l;
    public MyException() {
        
    }
    public MyException(String message) {
        super(message);
    }
}

class Student{
    private int id;
    public void regist(int id) {
        if(id>0) {
            this.id = id;
        }else {
            //throw new RuntimeException("您输入的数据非法");//可以不处理，如果是Exceprion ,必须处理；
            throw new MyException("您输入的数据非法");//抛出自定义异常
        }
    }
    public void regist1(int id) throws Exception {
        if(id>0) {
            this.id = id;
        }else {
            throw new Exception("您输入的数据非法");//可以不处理，如果是Exceprion ,则需要处理（两种方式），因为exception包括编译异常，所以必须要处理
            
        }
    }
}