Java第八章(异常)

一.Java 异常概述

异常:指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致JVM(虚拟机)的非正常停止,后续程序无法执行
     例如用户输入数据有问题,读写文件文件被强制删除,网络传输中,突然断网
(代码写错不是异常)

 1.Java中默认的异常处理机制:将出现的异常,按不同的类型分类,为每种异常封装了一个类来进行表示,当出现某种类型的异常情况时,会抛出此类的对象,然后终止虚拟机的运行

2.使用异常处理机制,对程序运行过程中出现的异常情况进行捕捉并处理

二.常见的异常 

常见的异常:
        int a=10;
        int b=0;
        int c=a/b;//Arithmetic Exception 算数异常

        int[]c=new int[2];
c[3]=0;//ArrayIndexOutOfBounds Exception 数组越界

        String s="abc";   s.charAt(4);//StringIndexOutOfBounds Exception 字符串索引越界

        Object s=new Integer(10);
        String s1=(String) s;//ClassCast Exception 类型转换异常

        Integer.parseInt("1c");//NumberFormat Exception 数字格式化异常

        String s=null;
s.length();//NullPointer Exception  使用null中的方法/属性  一般Java中也称为空指针异常

三.java异常体系结构

Throwable(异常体系的超类):
  1.Error:错误 是虚拟机和Java代码无法解决的问题
          例如虚拟机内部异常,内存不够用了
StackOverflow Error(栈溢出)
OutOfMemory Error(堆内存溢出)
  2.Exception:异常 这类异常是可以通过异常处理机制进行处理的一般性问题
其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。

四. 异常处理

Java编程语言使用异常处理机制为程序提供了异常处理能力

异常处理:
    在编码时,就针对可能出现问题的代码(经验问题)预习编写一些处理机制,
    程序运行
    出现异常
    执行处理机制
    继续运行后续程序

    /*
        try{
            编写可能出现异常的代码
         }catch(异常类型 ){
            处理机制
            }catch(Exception i){
        捕获任意类型异常,放在最后
    }        finallly{
        必须执行的代码
    }

     */

        int a=10;
        int b=0;
        String e=null;
        try{
            int c=a/b;//算术运算可能有问题
            e.length();
        }catch (ArithmeticException c){
            c.printStackTrace();//打印异常信息到控制台
            System.out.println("算数异常");
        }catch (Exception d){
            d.printStackTrace();
            System.out.println("系统忙");
        }finally {
            System.out.println("必须执行");
}

finally 使用的三个场景

场景1:异常没有被捕获到,后面代码无法执行,但是finally中代码是可以执行的

    public static void main(String[] args) throws IOException {

        String s="abc";
        try {
            s.charAt(4);
        }catch (ArithmeticException c){//异常类型不匹配
            System.out.println("字符串索引越界");
        }finally {
            System.out.println("必须执行");
        }
}

场景2: 确保在出现异常的情况下 依然最终把流对象关闭掉

 public static void main(String[] args) throws IOException {
            FileInputStream in=null;
        try{
            in=new FileInputStream("D:/");
            while (in.read()!=-1){

            }
        }catch (FileNotFoundException h){
            h.printStackTrace();
            System.out.println("文件找不到异常");
        }finally {
            if(in!=null){
                in.close();
            }

        }
}

场景3:无论是try中还是catch中进行return,也必须在return之前 先执行finally代码块

public static void main(String[] args) throws IOException {
     test(10,0);
}
    public  static int test(int a,int b){

        try{
            int c=a/b;
            //关闭流操作
            return c;
        }catch (ArithmeticException abc){
            abc.printStackTrace();
            System.out.println("算数异常");
            return -1;
        }finally {
            //关闭流操作
            System.out.println("关闭流");
        }

    }

 五.运行期异常和编译期异常

异常分为:

1.编译期异常:编译期间会主动提示程序员要进行处理的异常(编码不支持,文件找不到)

2.运行期异常(RuntimeExpectation):在编译期间不会主动提示程序员进行处理的异常(数组越界,算数异常,类型转换)

区别:在于异常有没有继承RuntimeExpectation

throws:用在方法声明部分,表示此方法中可能出现某种类型的异常,此方法不处理异常,谁调用谁处理

throw:在方法体中,抛出一个具体的 异常对象 ,该方法终止运行,在异常对象中的构造方法中自定义异常原因

六.自定义异常

根据自己需求自定义异常类,与Java类异常进行区分
  eg:
 分数自定义异常:
   当分数不合法时抛出此类的对象
   例如百分制分数,当输入小于0 大于100 时抛出

   public static void main(String[] args) {
        try {
            scor(-1);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }

    public static char scor(int score) throws ScoreException{
        if (score<0||score>100){
            throw new ScoreException("非法分数");//当不满足某种条件时,程序中主动的抛出异常对象,终止此方法继续向下执行,通过异常构造方法传入异常原因
        }else{
            return 'A';
        }
    }
//--------------------------------------

public class ScoreException extends Exception {
    public ScoreException(String  message){//定义构造方法,打印
        super(message);
    }
}