【Exception】

Kovyi_Mar25

已于 2023-04-12 09:15:57 修改

阅读量61

点赞数

分类专栏： java基础文章标签： java

于 2023-04-11 22:08:57 首次发布

本文链接：https://blog.csdn.net/wrrare/article/details/130085141

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Exception = 异常 =例外，程序运行过程中出现的例外情况而已
Error和Exception的区别？
1. Error通常只是由于硬件环境或者系统原因导致的相对较严重的问题[通过编码无法解决的问题]
2. Exception就是指运行过程当中出现的例外情况而已
运行时异常和非运行时异常的区别？
1. 运行时异常在编译的时候不要求程序员给出处理方案，编译能够直接通过，问题会在运行时直接体现出来，直接继承RuntimeException
2. 非运行时异常，在编译的时候就必须要求给出处理方案，否则编译直接报错，直接继承Exception
所有的异常都是在程序运行时出，编译的时候只是在翻译(给出要在运行时出问题的解决方案)
java当中会沿着关系继承树做语法检查的共有三种语法：
1. 强制类型转换
2. ==
3. instanceof
非运行时异常
1. AWTException：抽象窗口工具包异常
2. IOException：IO流异常
3. CloneNotSupportedException：克隆不被支持异常
我们所接触过的运行时异常有哪些? [常见的运行时异常有哪些?]

import java.util.*;
public class RuntimeException{
	public static void main(String[] args){
        //集合4个
        {//并发修改异常：ConcurrentModificationException
			ArrayList<Integer> list = new ArrayList<>(8);
			Collections.addAll(list,55,44,22,11);
			for(Integer i : list){
				list.add(66);
			}
		}
        {//!非法状态异常：IllegalStateException
            ArrayList<Integer> list = new ArrayList<>(8);
			Iterator car = list.iterator();
			car.remove();
        }
        {//索引值超出边界异常：IndexOutOfBoundsException
			ArrayList<Integer> list = new ArrayList<>(8);
			list.remove(8);
		}
        {//!非法参数异常：IllegalArgumentException
			ArrayList<Integer> list = new ArrayList<>(-7);
		}
                
        //类型转换1个
        {//类造型异常：ClassCastException
            Animal d = new Dog();
            Bird b = (Bird)d;
        } 
        
        class Animal{}
        class Bird extends Animal{}
        class Dog extends Animal{}    
        
        //字符串3个
        {//!数字格式化异常：NumberFormatException
            String str = "123a";
            System.out.println(Integer.parseInt(str));
        }
        {//字符串索引值超出边界异常：StringIndexOutOfBoundsException
            String str = "abc";
            System.out.println(str.charAt(3));
        }
        {//！空指针异常：NullPointerException
            String[] data = new String[3];
            System.out.println(data[0].length());
        }
    
        //数组3个
        {//！空指针异常：NullPointerException
            int[] data = new int[3];
            System.out.println(data[0].length);
        }
        {//数组索引值超出边界异常：ArrayIndexOutOfBoundsException
            int[] data = new int[3];
            System.out.println(data[4]);
        }
        {
        //负数数组大小异常：NegativeArraySizeException
            int[] data = new int[-7];
        }

        //运算符1个
        {    
        //算术异常：ArithmeticException
            System.out.println(7 / 0);
        }
    }
}

为什么要处理异常？
1. A--非运行时异常不做处理编译都无法通过
2. B--JVM是个特别严格的领导，一旦程序运行出现未做处理的异常，将直接中断程序的执行
如何处理异常？
1. 抛还上级：throws；throws用在方法签名的最后，用于表达本方法中出现指定种类的异常，本方法中不做处理，抛还给调用的上级进行处理...；足以解决A，但无力解决B
2. 自行处理：try catch finally
```
/**

try{

    可能出现异常的语句;

}catch(要捕获的异常类型 异常代号--起一个名字 ){
    
    对捕获到的异常进行处理
    
    常见的处理方式：
                    0.隐瞒不报：finally{ //啥也不写  }
                    1.简要的审
                        String msg = 异常代号.getMessage();
                        System.out.println(msg);
                    2.详细的审
                        异常代号.printStackTrace();
}finally{
    
    无论是否出现异常，最终都要执行的操作
    通常是释放和关闭资源的操作；    
}

*：一个try后面可以跟上多个catch，但是不允许前者包含后者类型
*：在jdk7.0之前...如果多个catch要做相同处理，也不许要写多个catch分支，代码很恶心，从7.0开始支持多重catch
    catch(类型1 | 类型2 e){//注意是一个|，表示连接符，不是逻辑或；只有一个异常代号也就是名字

!注意版本：jdk8.0
    局部内部类：如果定义在静态方法中：只能共享外部类静态成员
               如果定义在非静态方法中：能够共享外部类所有成员
               另外由于局部内部类定义在方法体当中，所以的外部类方法中的局部变量
    
    只是从jdk8.0之前，必须加final修饰；从jdk8.0开始，可以不加但是默认就是final  
        
}


*/
```
3. 如何在本没有异常的情况下，主动制造异常出现的场景
  1. throw 用在方法体当中，用于在本没有异常的情况下主动制造异常出现的场景【没事找事】
  2. throws 用在方法签名的最后，用于表达本方法当中出现指定种类的异常，方法当中不做处理，抛还给调用的上级进行处理【有事甩锅】
  3. *：1、2 即 throw和throws的区别
4. 如何自定义异常？
  1. 自己开发一个类，选择继承Exception(非运行时异常) / RuntimeException(运行时异常)
  2. 然后再其构造方法的首行使用super()；指定异常的描述信息
5. plus01：当类体当中某个静态变量是通过调用有异常声明的方法完成赋值的时候，我们不能在类签名上直接throws，更不能在类体当中直接try catch，此时，必须借助静态初始代码块，在静态初始代码块当中完成异常处理
  1. *：如果是非静态变量呢？可以使用非静态初始化代码块或者构造方法
6. plus02：如果父类方法没有任何throws声明，那么子类方法在覆盖它的时候，能不能向外抛出异常呢？可以，但是只能向外抛出运行时异常。因为java当中每个方法都默认抛出所有的运行时异常，相当于每个方法签名签名最后都有throws RuntimeException，但是这样的行为没有任何意义，因为运行时异常默认抛出
7. plus03：当代码逻辑当中出现连续多行有异常声明的方法调用，我们希望无论前者是否正常运行，后者都要尝试执行，此时必须借助try catch finally 的finally当中嵌套使用try catch，我们把这种语法戏称为“连环try”
8. plus04：为了进行异常处理而添加的try catch语法结构，是由大括号的，而这大括号同样能够控制变量的作用范围。如果想要在下文程序当中依然要使用这变量，则必须把定义拿到大括号的前面去，以默认值赋值。在大括号当中只做重新赋值，不做变量定义
9. plus05：在某些场景下，学会使用异常处理的语法结构，代替传统的分支判断。