什么是异常?异常的详细介绍

异常

什么是异常？（看代码）

public class Exception{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 0;
        // num1 /num2 => 10 /0
        // 所以程序会出现（抛出）异常
        // 当抛出异常后，程序就退出 崩溃了 下面的代码就不在执行
        int res = num1 / num2;
		// 如果程序员认为 一段代码可能出现异常/问题，可以使用 try-catch 异常处理机制来解决
        // idea  将代码选中->快捷键 ctrl + alt + t  -> 选中  try-catch
        // 如果进行异常处理机制，那么即使出现了异常，程序可以继续执行
        
        try{
            int res = num1 / num2;
        } catch (Exception e){
            System.out.println("出现异常的原因=" + e.getMessage()); // 输出异常信息
        }
        
        System.out.println("程序继续运行...");
    }
}

基本概念：

Java语言中，将程序执行中发生的不正常的情况称为 ”异常“

执行过程中所发生的异常事件可分为两大类：

1. Error（错误）：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。

比如：StackOverflowError(栈溢出) 和 OOM(out of memory)(内存不足)。 Error是严重错误，不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。

2. Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问，试图读取不存在的文件，网络连接中断等等， Exception分为两大类：运行时异常[程序运行时，发生的异常] 和 编译时异常[编译时，编译器发生的异常]

编译时异常（检查性异常）：最具代表的编译时异常是 用户错误或问题引起异常，这是程序员无法预见的。

例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略

运行时异常：运行时异常是可能被程序员避免的异常。与编译时异常相反，运行时异常可以在编译时被忽略。

异常体系图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sQpg1d6G-1662000173156)(E:\photo\博客\异常体系图.png)]

绿色的虚线表示 实现接口； 蓝色的实线表示 继承类

小结：

1. 异常分为两大类，运行时异常和编译时异常
2. 运行时异常，编译器不要求强制处置的异常。一般是指 编程时的逻辑错误，是程序员应该避免其出现的异常。如 java.lang.RuntimeException类以及它的子类都是运行时异常
3. 对于运行时异常，可以不做处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
4. 编译时异常，是编译器要求必须处置的异常。

运行时常见的异常：（基本上是程序员自身的问题）

1. NullPointerException 空指针异常： 当应用程序试图在需要对象的地方使用null 时，抛出该异常

public class NullPointerException {
    public static void main(String[] args) {
        String name = "Obito";
        // String name = null;  
        System.out.println(name.length()); // 输出 5
    }
}

2. ArithmeticException 数学运算异常: 当出现异常的运算条件时，抛出此异常。

例如：一个整数“除以0” 时，抛出此类的一个实例

3. ArrayIndexOutOfBoundsException 数组下标越界异常：用非法索引访问数组时抛出的异常。如果索引为负，或大于等于数组大小，则该索引为非法索引

public class ArrayIndexOutOfBoundsException{
    public static void main(String[] args) {
      int [] arr = {1,2,5};
        for (int i = 0; i <= arr.length; i++){
            System.out.println(arr[i]);
            // 前三个会顺利输出，因为没有arr[3] 所以会报下标越界异常
        }
    }
}

4. ClassCastException 类型转换异常：当试图将对象强转转换为不是实例的子类时，抛出该异常。

public class ClassCastException{
    public static void main(String[] args) {
        A b = new B(); // 向上转型
        B b2 = (B)b; // 向下转型
        C c2 = (C)b; // 这里抛出 ClassCastException
    }
}
class A{}
class B extends A{}
class C extends A{}

5. NumberFormatException 数字格式不正确异常：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出异常 => 使用异常我们可以确保输入时满足条件数字

public class NumberFormatException{
    public static void main(String[] args) {
        String name1 = "1234";
        //将String 转成 int
        int num1 = Integer.parseInt(name1); 
        System.out.println(num1); //1234
        
        String name2 = "宇智波带土";
        int num2 = Integer.parseInt(name2); //抛出NumberFormatException
        System.out.println(num2);
    }
}

异常的捕获：

public class Exception{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 0;
        // 如果不知道异常的情况 想要捕获多个异常 ：范围要  从小到大！
        try{  // try 监控区域
            
            if (num2 == 0){  // 抛出异常 throw  throws
                throw new ArithmeticException(); // 主动的抛出异常
            }
            
            System.out.println(num1 / num2);
   
            
        }catch (Error e){ // catch（想要捕获的异常类型！） 捕获异常
            System.out.println("Error"); 
        }catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally"); // 最后执行finally块里面的
        }
        
     	// finally 可以不要，等后面的 IO流 都会去执行 关闭资源
    }
}

方法中的异常与捕获：

public class Test{
    public static void main(String[] args){
        
        try{
            new Test().test(1,0); //使用匿名类
        } catch (ArirthmethicException e){
            e.printStackTrace();
        }
    }
    
    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if (b == 0){  
            throw new ArithmeticException(); // 主动抛出异常，一般在方法中使用
        }
    }
    
}

自定义异常：

​ 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。 用户自定义异常类，只需继承Exception类即可。

在程序中使用自定义异常类，大体可分为以下几个步骤：

1. 创建自定义异常类

2. 在方法中通过throw关键字抛出异常对象

3. 如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

4. 在出现异常方法的调用者中捕获并处理异常

// 自定义的异常类
public class MyException extends Exception{
    
    //
    private int detail;
    
    public MyException(int a){
        this.detail = a;
    }
    
    // toString: 异常的打印信息
    public String toString(){
        return "MyException{"  +  detail + '}';
    }
}


// 再定义一个测试类
public class Test{
    
    //可能会存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为：" + a);
        
        if (a > 10){
            throw new MyException(a);  // 抛出
        }
        
        System.out.println("ok");
    }
    
    public static void main(String[] args){
        try{
            test(11);
        } catch (MyException e) {
            System.out.println("MyException=>" + e);
        }
    }
}

小经验：

1. 处理运行时异常时，采用逻辑去合理规避 同时使用 try-catch 辅助处理
2. 在多重catch快后面，可以加一个catch(Exception) 来处理可能会被遗忘的异常
3. 对于不确定的代码，也可以加上 try-catch，处理潜在的异常
4. 尽量去处理异常，切忌只是简单的调用 printStackTrace() 去打印输出
5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用的资源。