从零开始的Java异常

异常

1.异常的概念：

• 广义：一切不正常情况
• 狭义：程序在运行时，出现的不正常情况，经过异常处理机制 后，程序可以继续向下运行。

Java程序在执行过程中所发生的的异常（运行时一切不正常情况）事件可分为两类：

• **Error：**Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。
• **Exception：**其它因编程错误或偶然的外在因素导致的一般性问题，可以使用正对性的代码进行处理。

2.常见的异常：

      /*
        常见异常：
         */
        //1.数组索引越界    java.lang.ArrayIndexOutOfBoundsException
         int[] a = new int[5];
         a[5] = 10;

        //2.空指针异常   java.lang.NullPointerException
         String s = null;
         s.length();

        //3.类型转换异常   ClassCastException
        // java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
        Object obj = "abc";
        Integer i = (Integer) obj;

        //4.数字格式化异常   java.lang.NumberFormatException
        new Integer("abc");

        //5.算数异常    java.lang.ArithmeticException: / by zero  除数不能为0
        int a = 10;
        int b = 0;
        System.out.println(a/b);

3.异常的体系

java.lang.Throwable类有两个直接子类，Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类。

• Throwable类是Java语言中所有错误和异常的Throwable类。

异常分为运行期异常和编译期异常两种。

• 运行期异常：程序运行时抛出的异常，所有RuntimeException的子类（直接或间接继承RuntimeException）都是运行期异常，在编译期间不强制要求处理。
• 编译期异常：除去运行期的异常都是编译期异常，也称为检测/检查异常，直接或间接继承Exception，与RuntimeException没有关系，在编译期间需要强制处理。

4.异常的处理

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

Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

try-catch-finally

**try：**try是检测不安全的代码块。即try块中放的是可能会发生异常的代码。try中的任何一条语句发生了try中的任何一条语句发生了异常，下面的代码都将不会执行，程序将跳转到异常处理代码块中，即catch块。

**catch：**捕获try块中出现的类型匹配的异常，保证程序能继续运行下去。catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数。一个try后面可以写多个catch，分别捕获不同类型的异常，这些catch后的要捕获的异常类型中，要按照从小到大的顺序，即从子类到父类的顺序写，否则会编译错误。

catch中提供方法捕获异常的有关信息：与其他对象一样，可以访问一个异常对象的成员变量或调用它的方法。

• getMessage() 获取异常信息，返回字符串
• printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。

**finally：**无论是否发生异常，finally块中的代码都会执行，且只能有一个finally语句。

基本语法：
格式一：
try{
      可能会发生异常的代码
  }catch(异常类型（只捕获指定异常的类型） 引用名){
      异常的处理的代码
  }
  //try块中可以再放try-catch组合块，也可以只放try块，把catch块放到自己的catch块后。
格式二：
  try{
      可能会发生异常的代码
  }catch(异常类型（只捕获指定异常的类型） 引用名){
      异常的处理的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
格式三：
 try{
      可能会发生异常的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
  
注：catch语句必须紧跟着try语句之后，且一个try后面可以写多个catch。

格式一示例：

 public static void main(String[] args) {

       try{
           
           int[] c = {1,2,3};
           c[3] = 4;//数组索引越界
          /* try{
               String s = null;
               s.length();
           }catch(NullPointerException n){
               System.out.println("空指针异常");
           }*/

           int a = 10;
           int b = 0;
           System.out.println(a/b);//除数不能为0
           System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行
       }catch(ArithmeticException a ){
           System.out.println("算数异常");//异常的处理
       }catch (ArrayIndexOutOfBoundsException a){
           System.out.println("数组索引越界");
       }catch (Exception e){
           System.out.println("存在异常，请处理！");
       }
     //try块中可以跟多个catch块，且这些catch块中catch后的要捕获的异常类型中，要按照从小到大的顺序，即从子类到父类的顺序写，否则会编译错误。
       
        System.out.println("hello world!");//由于异常被catch块捕获，因此该语句会执行
    }

格式二示例：

 public static void main(String[] args) {
     
      try{
            int[] c = {1,2,3};
            c[3] = 4;//数组索引越界
            System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行;
        }catch (Exception e){
            System.out.println("存在异常，请处理！");//处理1：对用户进行提示
        }finally {  //无论是否发生异常，finally块中的代码都会执行
            System.out.println("hello world");
        }
        
    }

格式三示例：

 public static void main(String[] args) {

        try{
            int[] c = {1,2,3};
            c[3] = 4;//数组索引越界
            System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行;
        }finally {  //try + finally组合，此处没有异常处理，try块中一旦出现异常，执行finally块，程序终止
            System.out.println("hello world");
        }

    }

throw-throws

throw：throw关键字用于显示抛出异常，抛出的时候是抛出的是一个异常类的实例化对象。在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

throws：定义一个方法的时候，可以使用throws关键字声明方法中可能会出现的异常(可以同时声明多个可能会出现的异常) 表示此方法不处理异常，交给方法调用处处理异常， 一般多为编译期异常（检查异常）。

• 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
• 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常（针对编译期异常）。
• 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明

自定义异常

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类。

作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆。

public class ExceptionDemo8 {
    public static void main(String[] args) {
        ExceptionDemo8 d8 =new ExceptionDemo8();
         //使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch,要么继续使用throws声明。
        try {
            d8.checkScore(101);
        } catch (ScoreException e) {
            e.getMessage();
            System.out.println(e.getMessage());
            e.printStackTrace();
        }

    }

    /*
    throws, 定义一个方法的时候，可以使用throws关键字声明方法中可能会出现的异常，可以同时声明多个可能会出现的异常
            表示此方法不处理异常，交给方法调用处处理异常
            一般多为编译期异常（检查异常）
     */
    public String checkScore(int score) throws ScoreException{
        if(score<0 ||score>100){
        //ScoreException 为自定义的异常类    
            throw new ScoreException("成绩不合法");
            //当不满足某种条件时，在方法中显式的抛出一个异常对象，程序终止
        }
        if(score>=90){
            return "优秀";
        }else {
            return "不优秀";
        }
    }
}