2022/1/21
1.异常
程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。
异常并不是指语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行。
2.异常体系
异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,其下有两个子类:java.lang.Eror与java.lang.Exception.
Error:是指出现了错误。(很严重)
Exception:是指出现了异常。(解决了异常程序就可以正常运行)
3.异常产生的过程解析
1)访问数组中没有的索引,这时候JVM就会检测出程序会出现异常
JVM会做两件事情:
<1>JVM会根据异常产生的原因创建一个异常对象,这个异常对象包含了异常产生的(内容,
原因,位置)
<2>在出错的那个方法中,没有异常处理逻辑(try...catch),那么JVM就会把异常对象抛出
给方法的调用者main方法来处理这个异常。
2)main方法接受到了这个异常对象,main方法也没有异常处理逻辑,继续把对象抛出给main方法的调用者JVM处理
3)JVM接收到了这个对象,又做了两件事
<1>把异常对象(内容,原因,位置)以红色的字体打印在控制台
<2>JVM会终止当前正在执行的Java程序-->中断处理
4.throw关键字
package ln.javatest.day12.demo03;
/*
throw关键字
作用:
可以使用throw关键字在指定的方法中抛出指定的异常
使用格式:
throw new xxxException("异常产生的原因");
注意:
1.throw关键字必须卸载方法的内部
2.throw关键字后面new的对象必须是Exception或者Exception的子类对象
3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
throw关键字后边创建的是RuntimeException或者是RuntimeException的子类,我们可以不处理,默认交给JVM处理(打印异常对象,终端程序)
throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch(eg.SimpleDateFormat)
*/
public class Demo01Throw {
/*
定义一个方法,获取数组指定索引处的元素
参数:
int[] arr
int index
以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
如果参数不合法,我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
*/
public static void main(String[] args) {
//int[] arr = null;
int[] arr = {1,2,3};
int a = getElement(arr,3);
System.out.println(a);
}
public static int getElement(int[] arr,int index){
/*
我们可以对传递过来的参数数组,进行合法性校验
如果数组arr的值是null
那么我们就抛出空指针异常,告知方法的调用者“传递的数组的值是null”
*/
if(arr == null){
throw new NullPointerException("传递的数组的值是null");
}
/*
我们可以对传递过来的参数index进行合法性校验
如果index的范围不在数组的索引范围内
那么我们就抛出数组索引越界异常,告知方法的调用者“传递的索引超出了数组的使用范围”
*/
if(index<0 || index>arr.length-1){
throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
}
int ele = arr[index];
return ele;
}
}
5.Objects非空判断,requireNonNull
package ln.javatest.day12.demo03;
/*
Objects类中的静态方法
public static <T> T requireNonNull(T obj):查看指定引用对象不是null。
源码:
public static <T> T requireNoneNull(T obj) {
if(obj == null)
throw new NullPointerException();
return obj;
}
*/
import java.util.Objects;
public class Demo02Objects {
public static void main(String[] args) {
method(null);
}
private static void method(Object obj) {
//对传递过来的参数进行合法性判断,判断是否为null
/*if(obj == null){
throw new NullPointerException("传递的对象的值是null");
}*/
//Objects.requireNonNull(obj);
Objects.requireNonNull(obj,"传递的对象的值是null");
//上面三个效果一样
}
}
6.异常处理的第一种方式:throws关键字,交给别人处理
package ln.javatest.day12.demo03;
/*
throws关键字:异常处理的第一种方式,交给别人处理
作用:
当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理,最终交给JVM处理-->中断处理
使用格式:在方法的声明时使用
修饰符 返回值类型 方法名(参数列表) throws XXXException,XXXException...{
throw new XXXException(“产生原因”);
throw new XXXException(“产生原因”);
}
注意:
1.throws关键字必须写在方法声明处
2.throws关键字后面声明的异常必须是Exception或者是Exception的子类
3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
4.调用了一个声明抛出异常的方法,我们就必须得处理声明的异常
要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
要么try...catch自己处理异常
*/
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;
public class Demo03Throws {
/*
FileNotFoundException extends IOException extends Exception
*/
public static void main(String[] args)throws IOException{
readFile("c:\\a.txt");
}
/*
定义一个方法,对传递的文件路径进行合法性判断
如果路径不是“c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者
注意:
FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
*/
public static void readFile(String fileName) throws IOException{
if(!fileName.equals("c:\\a.txt")){
throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
}
/*
如果传递的路径,不是,txt结尾
那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
*/
if(!fileName.endsWith(".txt")){
throw new IOException("文件的后缀名不对");
}
System.out.println("路径没有问题,读取文件");
}
}
7.异常处理的第二种方式:try...catch,自己处理
8.Throwable类中的3个异常处理方法
使用throws处理异常后,JVM直接中断程序,后续代码不再运行
try...catch可以实现后续代码接着运行
package ln.javatest.day12.demo03;
/*
try...catch:异常处理的第二种方式,自己处理异常
格式:
try{
可能产生异常的代码
}catch(定义一个异常的变量,用来接收try中抛出的异常对象){
异常的处理逻辑,接收异常对象之后,怎么处理异常对象
一般在工作中,会把异常的信息记录到一个日志中
}
...
catch(异常类名 变量名){
}
注意:
1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码。
如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行try中的代码,继续执行try...catch之后的代码。
*/
import java.io.IOException;
public class Demo04TryCatch {
public static void main(String[] args) {
try {
readFile("d:\\a.tx");
}catch(IOException e){ //try中抛出什么异常,catch就定义什么异常变量,用来接收这个异常对象