Java基础 | 异常处理

1.异常概述

写代码时候，程序执行中发生的的错误或不正常清空都统称为”异常”。
又根据错误的不同分为error和exception两种异常

1.1Error异常

  1. JVM都无法解决的异常

  2. 具体体现，JVM内部资源耗尽，系统内部错误

  3. 比如OOM StackOverFlowError等等

  4. 不编写针对性代码进行处理

1.2Exception异常

  1. 此类异常常见于开发中

  2. 因为编程错误或偶然外在因素造成的一般问题

  3. 可以编写针对性代码进行处理

1.3抓抛模式

  • 所谓抓就是处理这些异常的方式常见的两种
    try catch finally 与 throws

  • 所谓抛就是程序在执行过程中一旦出现了异常
    就会在异常代码处生成一个对应异常类的对象
    异常抛出后，后面的代码就不会再执行

1.4Throwable接口

Throwable本身是一个接口，它的实现类error和exception是开发中常用的异常类
它的内部也定义了一些常用方法去供实现类去调用，具体的用法可以查看API

1.5Exception异常分类

所有的RuntimeExpection及其子类的实例都被称作为运行时异常
其他的则为编译时异常

编译时异常:
Java程序必须显示处理结果,否则程序会发生错误,无法通过编译
解释:编译某个程序的时候,比如文件找不着了,这样的异常就必须编译的时候处理,如果不处理编译就不会通过

运行时异常:
无需显示处理,也可以和编译时异常一样处理
解释:就是程序员犯的错误,需要回来修改代码

1.5JVM处理异常

自己解决问题,然后继续运行

没有处理方式,只能交给调用main的jvm来处理

JVM有一个默认的处理机制,就将该异常进行处理

并将该异常的名称,异常的信息,异常位置打印在控制台,然后结束程序运行

1.6自定义异常

通过自定义的名字知道到底是什么异常,有针对的解决办法
如果jdk没有提供对应的异常就自己自定义一个异常

1
2
3
class AutoException extends Exception{
    里面写构造器并用super调用父类的构造器
}

1.7重写问题

子类重写父类方法:
子类抛出的异常一定不能比父类的大

父如果抛多个异常:
子类只能抛相同异常(或子集异常)

若重写方法没抛异常:
子的方法不能抛异常,若重写方法内有异常出现,
子只能try_catch_finally而不能throws

2.Try_Catch_Finally

  1. try:检查异常 catch:捕获异常 finally:释放资源

  2. 当通过try catch把问题处理后,程序会继续执行

  3. Exception是所有异常的父类

与注释区别
Try Catch就是进行包裹异常的
注释的作用是你的思路(开发中一定要写注释)

1
2
3
4
5
6
7
try {
    会出异常的代码
}catch (具体异常){
   提示语句
}finally{
     释放资源或者一定会执行的代码
}

2.1注意事项

  1. try用来把出异常的代码包裹起来

  2. catch中写如异常对象，进行匹配后再运行就不报错

  3. try匹配到catch就跳出当前结构，后面的代码可正常运行

  4. catch中的异常如果有子父类关系，子类在上(若没有声明声明就不需要具体顺序)

  5. getMessage()与printStackTrace()方法在catch中经常使用

  6. try中声明好的变量，出了结构就无法调用

2.2JDK7新特征

  1. 不用写多个catch只需要在多个异常中间加 | 即可实现包裹多个异常

  2. 前期不推荐这样写，易混淆，建议一个异常对应一个catch包

  3. 后期根据需求写法:
    安卓,客户端开发,处理异常一般用try{}catch(Exception e){}
    EE，服务器开发,一般都是用底层开发,从底层向上抛

1
2
3
4
5
6
7
8
9
try {
    System.out.println(a/b);
    System.out.println(arr[5]);
 //所有异常的父类就是Exception
//}catch (Exception e){
}catch (ArithmeticException  | 
	ArrayIndexOutOfBoundsException E){
    System.out.println("Software error");
}

2.3Finally关键词

  1. finally用于释放资源,在IO流操作和数据库操作中体会

  2. 写在finally结构里面的语句一定会被执行

  3. 特殊情况下不执行,如System.exit(0);

  4. 在return结束之前会考虑有没有其他东西需要执行

  5. 如果有就添加finally并执行后再彻底结束返回

  6. finally关键字可有可无

1
2
3
4
5
6
7
8
9
10
11
12
int[] arr = {1, 234, 35};
try {
	System.out.println(arr[5]);
	//如果用了这个语句就不会出现finally语句的 直接结束jvm
	//System.exit(0); 
} catch (Exception e) {
	e.printStackTrace();
	return ;
} finally {
	//finally下的句子必须执行除非特殊情况
	System.out.println("记得查看apiNaote");
}

3.Throws

throws就是抓抛模式的抛
它本身并不能真正解决异常的实际问题
它只是把问题从一个方法体抛给了另外一个方法体
最终的处理还是需要用try_catch进行处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   public static void main(String[] args) {
       //甩到main方法就没法甩了必须做出处理
       try {
           method2();
       } catch (IOException e) {
           e.printStackTrace();
       }finally {
           System.out.println("可能文件的路径存在一定问题");
       }
   }

   //method2接盘method1发现没救继续甩锅
   public static void method2() throws IOException{
       method1();
   }


   public static void method1() throws FileNotFoundException, IOException {
     exception code
}

4.三T的区别

Throw:

  • 用在方法体内,跟的是异常对象名
  • 只能抛出一个异常对象名
  • 表示抛出异常,由方法体内的语句处理

Throws:

  • 用在方法声明后面,跟的是异常类名
  • 可以跟多个异常类名,用逗号隔开
  • 表示抛出异常,由该方法的调用者来处理

Throwable

  • Throwable是一个接口
  • 接口中定义了一些通用的方法
  • 它的实例类为Error和Exception
  • 方法一般通过实例类去调用

5.三F的区别

Final:

  • 修饰类，类不能被继承
  • 修饰方法，方法不能被重写
  • 修饰变量，只能赋值一次

Finally:

  • 作为try catch中的语句体
  • 不能单独使用,用来释放资源用的

Finalize:

  • Object类的方法
  • 当垃圾回收器确定不存在该对象的更多引用时,由对象的垃圾回收器调用此方法。
  • 注:不要在finalize里写return,因为finalize的作用就是为了释放资源,是肯定会执行的,若写了,try和catch就失效了。
Java
#面向对象
Java基础 | 异常处理
http://example.com/2022/04/23/Java初级部分/异常处理/
Author
John Doe
Posted on
April 23, 2022
Licensed under