JAVA异常处理

一、java异常处理机制

java 中所有错误的超类为 :Throwable 。其下有两个子类 :Error 和 Exception

Error 的子类描述的都是系统错误，比如虚拟机内存溢出等。

Exception 的子类描述的都是程序错误，比如空指针，下表越界等。

通常我们程序中处理的异常都是 Exception 。

1.异常处理机制中的try-catch

代码演示如下：

package exception;
/**
* 异常处理机制中的try-catch
* 语法:
* try{
* 代码片段...
* }catch(XXXException e){
* 出现错误后的补救措施(B计划)
* }
*/
public class TryCatchDemo {
public static void main(String[] args) {
System.out.println("程序开始了...");
/*
try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块
异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
*/
try {
// String str = null;
// String str = "";
String str = "a";
/*
若str=null的情况
当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
虚拟机会将该异常抛出
当某句代码抛出了一个异常时，JVM会做如下操作:
1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
异常处理动作
2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
代码片段处理该异常
*/
System.out.println(str.length());//抛出空指针异常
System.out.println(str.charAt(0));
System.out.println(Integer.parseInt(str));
/*
当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
*/
System.out.println("!!!!!!!!!!!!!!");
// }catch(NullPointerException e){
// //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
// System.out.println("出现了空指针，并解决了!");
// }catch(StringIndexOutOfBoundsException e){
// System.out.println("处理字符串下标越界问题!");
// }
/*
当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
同一个。
*/
}catch(NullPointerException|StringIndexOutOfBoundsException e){
System.out.println("处理空指针或下标越界!");
/*
当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
catch块捕获并处理。
如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
*/
}catch(Exception e){
System.out.println("反正就是出了个错!");
}
System.out.println("程序结束了...");
}
}

2.异常处理机制中的finally

finally 块定义在异常处理机制中的最后一块。它可以直接跟在 try 之后，或者最后一个 catch 之后。

finally 可以保证只要程序执行到了 try 语句块中，无论 try 语句块中的代码是否出现异常，最终 finally

都必定执行。

finally 通常用来做释放资源这类操作。

代码演示如下：

package exception;
/**
* finally块
* finally块是异常处理机制中的最后一块，它可以直接跟在try语句块之后或者最后一个catch块
* 之后。
* finally可以保证只要程序执行到try语句块中，无论try语句块中的代码是否出现异常，finally
* 都【必定执行】!
* 通常finally块用于做释放资源这类操作，比如IO操作后的关闭流动作就非常适合在finally中进行
*/
public class FinallyDemo {
public static void main(String[] args) {
System.out.println("程序开始了...");
try{
String str = "abc";
System.out.println(str.length());
return;
}catch(Exception e){
System.out.println("出错了，并处理了");
}finally{
System.out.println("finally中的代码执行了!");
}
System.out.println("程序结束了");
}
}

3.IO操作时的异常处理机制应用

代码演示如下：

package exception;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 异常处理机制在IO中的实际应用
*/
public class FinallyDemo2 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos.dat");
fos.write(1);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fos!=null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

4.自动关闭特性

JDK7 之后， java 提供了一个新的特性 : 自动关闭。旨在 IO 操作中可以更简洁的使用异常处理机制完成最后 的close 操作。

语法 :

try (

定义需要在 finally 中调用 close () 方法关闭的对象 .

){

IO 操作

} catch ( XXXException e ){

...

}

上述语法中可在 try 的 "()" 中定义的并初始化的对象必须实现了 java.io.AutoCloseable 接口 , 否则编译不通 过.

代码演示如下：

package exception;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* JDK7之后java推出了一个特性:自动关闭特性
* 旨在让我们用更简洁的语法完成IO操作的异常处理机制(主要就是简化了finally关闭流的操作)
*/
public class AutoCloseableDemo {
public static void main(String[] args) {
/*
该特性是编译器认可的，并非虚拟机。实际上编译器编译完毕后的样子可参考FinallyDemo2
*/
try(
//只有实现了AutoCloseable接口的类才可以在这里定义!编译器最终会补充代码在
finally中调用其close关闭
FileOutputStream fos = new FileOutputStream("fos.dat");
){
fos.write(1);
} catch (IOException e) {
e.printStackTrace();
}
}
}

上述代码是编译器认可的，而不是虚拟机。编译器在编译上述代码后会在编译后的 class 文件中改回成

FinallyDemo2 案例的代码样子 ( 上次课最后的案例 ) 。

5.throw关键字

throw 用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常 :

1: 当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。

2: 程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。

package exception;
/**
* 测试异常的抛出
*/
public class Person {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) throws Exception {
if(age<0||age>100){
//使用throw对外抛出一个异常
throw new RuntimeException("年龄不合法!");
}
this.age = age;
}
}
package exception;
/**
* throw关键字，用来对外主动抛出一个异常。
* 通常下面两种情况我们主动对外抛出异常:
* 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
* 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
*/
public class ThrowDemo {
public static void main(String[] args) {
Person p = new Person();
p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
System.out.println("此人年龄:"+p.getAge());
}
}

当一个方法中使用 throw 抛出一个非 RuntimeException 的异常时，就要在该方法上使用 throws 声明这个

异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。

package exception;
/**
* 测试异常的抛出
*/
public class Person {
private int age;
public int getAge() {
return age;
}
/**
* 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
*/
public void setAge(int age) throws Exception {
if(age<0||age>100){
//使用throw对外抛出一个异常
// throw new RuntimeException("年龄不合法!");
//除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
throw new Exception("年龄不合法!");
}
this.age = age;
}
}

当我们调用一个含有 throws 声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通

过。 处理手段有两种 :

使用 try-catch 捕获并处理这个异常

在当前方法 ( 本案例就是 main 方法 ) 上继续使用 throws 声明该异常的抛出给调用者解决。 具体选取

那种取决于异常处理的责任问题。

package exception;
/**
* throw关键字，用于主动对外抛出一个异常
*/
public class ThrowDemo {
public static void main(String[] args){
System.out.println("程序开始了...");
try {
Person p = new Person();
/*
当我们调用一个含有throws声明异常抛出的方法时,编译器要求
我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
1:使用try-catch捕获并处理异常
2:在当前方法上继续使用throws声明该异常的抛出
具体用哪种取决于异常处理的责任问题
*/
p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
System.out.println("此人年龄:"+p.getAge()+"岁");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("程序结束了...");
}
}

注意，永远不应当在main方法上使用throws!!

6.含有throws的方法被子类重写时的规则

package exception;
import java.awt.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
/**
* 子类重写超类含有throws声明异常抛出的方法时对throws的几种特殊的重写规则
*/
public class ThrowsDemo {
public void dosome()throws IOException, AWTException {}
}
class SubClass extends ThrowsDemo{
// public void dosome()throws IOException, AWTException {}
//可以不再抛出任何异常
// public void dosome(){}
//可以仅抛出部分异常
// public void dosome()throws IOException {}
//可以抛出超类方法抛出异常的子类型异常
// public void dosome()throws FileNotFoundException {}
//不允许抛出额外异常(超类方法中没有的,并且没有继承关系的异常)
// public void dosome()throws SQLException {}
//不可以抛出超类方法抛出异常的超类型异常
// public void dosome()throws Exception {}
}

7.含有throws的方法被子类重写时的规则

package exception;
import java.awt.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
/**
* 子类重写超类含有throws声明异常抛出的方法时对throws的几种特殊的重写规则
*/
public class ThrowsDemo {
public void dosome()throws IOException, AWTException {}
}
class SubClass extends ThrowsDemo{
// public void dosome()throws IOException, AWTException {}
//可以不再抛出任何异常
// public void dosome(){}
//可以仅抛出部分异常
// public void dosome()throws IOException {}
//可以抛出超类方法抛出异常的子类型异常
// public void dosome()throws FileNotFoundException {}
//不允许抛出额外异常(超类方法中没有的,并且没有继承关系的异常)
// public void dosome()throws SQLException {}
//不可以抛出超类方法抛出异常的超类型异常
// public void dosome()throws Exception {}
}

8.Java异常可以分为可检测异常，非检测异常：

可检测异常：可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或

声明规则，不捕捉这个异常，编译器就通不过，不允许编译

非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当

操作，编译器不会检查是否已经解决了这样一个异常

RuntimeException 类属于非检测异常，因为普通 JVM 操作引起的运行时异常随时可能发生，此类

异常一般是由特定操作引发。但这些操作在 java 应用程序中会频繁出现。因此它们不受编译器检查

与处理或声明规则的限制。

9.常见的RuntimeException子类

IllegalArgumentException ：抛出的异常表明向方法传递了一个不合法或不正确的参数

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

ArrayIndexOutOfBoundsException ：当使用的数组下标超出数组允许范围时，抛出该异常

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

NumberFormatException ：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换

为适当格式时，抛出该异常。

10.异常中常用的方法

package exception;
/**
* 异常常见的方法
*/
public class ExceptionApiDemo {
public static void main(String[] args) {
System.out.println("程序开始了");
try {
String str = "abc";
System.out.println(Integer.parseInt(str));
} catch (NumberFormatException e) {
//异常最常用的方法,用于将当前错误信息输出到控制台
e.printStackTrace();
//获取错误消息.记录日志的时候或提示给用户可以使用它
String message = e.getMessage();
System.out.println(message);
}
System.out.println("程序结束了");
}
}

11.自定义异常

自定义异常通常用来定义那些业务上的异常问题。

定义自定义异常需要注意以下问题 :

异常的类名要做到见名知义

需要是 Exception 的子类

提供超类异常提供的所有种类构造器

package exception;
/**
* 非法的年龄异常
*
* 自定义异常通常用来说明业务上的错误.
* 自定义异常要注意以下问题:
* 1:定义的类名要做到见名知义
* 2:必须是Exception的子类
* 3:提供Exception所定义的所有构造方法
*/
public class IllegalAgeException extends Exception{
public IllegalAgeException() {
}
public IllegalAgeException(String message) {
super(message);
}
public IllegalAgeException(String message, Throwable cause) {
super(message, cause);
}
public IllegalAgeException(Throwable cause) {
super(cause);
}
public IllegalAgeException(String message, Throwable cause, boolean
enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
package exception;
/**
* 测试异常的抛出
*/
public class Person {
private int age;
public int getAge() {
return age;
}
/**
* 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
*/
public void setAge(int age) throws IllegalAgeException {
if(age<0||age>100){
//使用throw对外抛出一个异常
// throw new RuntimeException("年龄不合法!");
//除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
// throw new Exception("年龄不合法!");
//抛出自定义异常
throw new IllegalAgeException("年龄超范围:"+age);
}
this.age = age;
}
}
package exception;
/**
* throw关键字，用于主动对外抛出一个异常
*/
public class ThrowDemo {
public static void main(String[] args){
System.out.println("程序开始了...");
try {
Person p = new Person();
/*
当我们调用一个含有throws声明异常抛出的方法时,编译器要求
我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
1:使用try-catch捕获并处理异常
2:在当前方法上继续使用throws声明该异常的抛出
具体用哪种取决于异常处理的责任问题
*/
p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
System.out.println("此人年龄:"+p.getAge()+"岁");
} catch (IllegalAgeException e) {
e.printStackTrace();
}
System.out.println("程序结束了...");
}
}

总结：

1.java异常处理机制:

异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。

而如果通过修改逻辑可以规避的异常是 bug ，不应当用异常处理机制在运行期间解决！应当在编码

时及时修正

try 语句块用来包含可能出错的代码片段

catch 用来捕获并处理对应的异常，可以定义多个，也可以合并多个异常在一个 catch 中。 finally 是异常的最后一块，只要程序执行到 try 中则必走。一般用于释放资源这类操作。

throw 用于主动对外抛出异常。要么是满足语法不满足业务主动抛出异常，要么就是实际发生了异常但

是不应当在当前代码片段被解决是抛出。具体情况要结合实际业务分析。

throws 用于在方法声明时声明该异常的抛出，使得调用者必须处理该异常

异常的自我总结大概就这些，有不足和错误的地方望大家评论区留言！！！