大家好 , Java 专栏本应该早就完成的
但是之前发表异常的文章的时候 , 超过当天发布文章限制了
所以那时候就没上传成功 , 真的深感抱歉
刚才发现竟然少文章了
另外祝大家新年快乐
大年初七别忘了吃面条
一、异常的概念与体系结构
1.1 异常的概念
在计算机程序运行的过程中,总是会出现各种各样的错误。
在Java
中,将程序执行过程中发生的不正常的行为叫做异常.
我们以前也见到过许多异常,比如
-
算数异常
//算术异常 public static void main(String[] args) { System.out.println(10/0); }
-
数组越界异常
//数组越界异常 public static void main(String[] args) { int[] array = {1,2,3};//只有三个元素 System.out.println(array[100]);//访问下标为100的元素,数组中没有就会报错 }
-
空指针异常
//空指针异常 public static void main(String[] args) { int[] array = null;//先让数组什么都不指向 array[1] = 99;//报错:因为数组根本没指向任何对象,操作数组就会发生空指针异常 }
那么我们可以看出来,每一个异常对应的都是一个类.
1.2 异常的体系结构
1.3 异常的分类
1.3.1 编译时异常(受查异常)
在编译期间发生的错误,叫做编译时异常(也叫受查异常)
1.3.2 运行时异常(非受查异常)
在程序执行期间发生的错误,叫做运行时异常(也叫非受查异常)
RunTimeException
及其子类对应的异常.都叫做运行时异常
要注意:我们少写了个分号 括号这种算语法错误,不算异常
真正的异常是指程序变异之后得到
class
文件,再通过JVM
执行发现错误
二、异常的处理
2.1 防御型编程
2.1.1 LBYL
在操作前就做好充分的检查,即:事前防御型,每做一步都要检查
形象一点就是:刚交往的男女生,男生想要牵手之前先问问,想要抱抱时候也要先问问
boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
}
ret = 开始匹配();
if (!ret) {
处理匹配错误;
return;
}
ret = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
}
ret = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
}
ret = 载入游戏画面();
if (!ret) {
处理载入游戏错误;
return;
}
......
缺陷:正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱。
2.1.2 EAFP
先进行操作,遇到问题再处理,即:事后认错性.
形象一点就是男女朋友,男生想亲亲,直接就霸王硬上攻,过后再说"宝宝我错了".
语法:
//捕获异常使用try...catch语句,把可能发生异常的代码放到try {...}中,然后使用catch捕获对应的Exception及其子类:
try {
} catch() {
} catch() {
}
...
刚才的例子接下来这么写
try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}
......
优势:正常流程和错误流程是分离开的, 程序员更关注正常流程,代码更清晰,容易理解代码
在Java
中,异常处理主要的5个关键字:throw、try、catch、final、throws
。
2.2 异常的抛出
在编写程序时,如果程序中出现错误,此时就需要将错误的信息告知给调用者,比如:参数检测。
在Java
中,可以借助throw
关键字,抛出一个指定的异常对象,将错误信息告知给调用者。具体语法如下:
throw new XXXException("异常产生的原因");//自定义异常会出现的多一些
举个栗子:
public class TestDemo1 {
public static void func(int a) {
if(a == 10) {
throw new RuntimeException("a==10");
}
}
public static void main(String[] args) {
func(10);
}
}
注意:
-
throw
必须写在方法体内部 -
抛出的对象必须是
Exception
或者他的子类 -
如果抛出的是
RuntimeException
或者他的子类,那么我们可以不用处理,交给JVM
帮我们处理 -
如果抛出的是编译时异常,用户必须处理,否则无法通过编译
-
异常一旦抛出,其后的代码就不会执行
2.3 异常的捕获
异常的捕获,也就是异常的具体处理方式,主要有两种:异常声明throws
以及 try-catch
捕获处理。
2.3.1 异常的声明
在方法的参数列表后面写 throws
, 当方法中抛出编译时异常,用户不想处理该异常,此时就可以借助 throws
将异常抛
给方法的调用者来处理。即当前方法不处理异常,提醒方法的调用者处理异常。直到遇到某个 try ... catch
被捕获为止:
public class TestDemo1 {
public static void func(int a) throws CloneNotSupportedException {
if(a == 10) {
throw new RuntimeException("a==10");
}
}
public static void main(String[] args) {
func(10);
}
}
注意:
-
throws
必须跟在方法的参数列表之后 -
声明的异常必须是
Exception
以及 他的子类 -
方法内部如果抛出了多个异常,
throws
之后必须跟多个异常类型,之间用逗号隔开,如果抛出多个异常类型具有父子关系,直接声明父类即可。public class TestDemo1 { //throws:声明了一下异常,但是并没有处理异常 public static void func(int a) throws RuntimeException,NullPointerException { if(a == 10) { throw new RuntimeException("a==10"); } else { throw new NullPointerException("a == 其他"); } } public static void main(String[] args) { func(10); } }
-
调用声明抛出异常的方法时,调用者必须对该异常进行处理,或者继续使用
throws
抛出public class TestDemo1 { public static void func(int a) throws RuntimeException,NullPointerException { if(a == 10) { throw new RuntimeException("a==10"); } else { throw new NullPointerException("a == 其他"); } } public static void main(String[] args) throws Exception { func(10); } }
2.3.2 try-catch捕获并处理
throws
对异常并没有真正处理,而是将异常报告给抛出异常方法的调用者,由调用者处理。如果真正要对异常进行处理,就需要try-catch
。
try {
// 将可能出现异常的代码放在这里
} catch (要捕获的异常类型 e) {
// 如果try中的代码抛出异常了,此处catch捕获时异常类型与try中抛出的异常类型一致时,或者是try中抛出异常的基类时,就会被捕获到
// 对异常就可以正常处理,处理完成后,跳出try-catch结构,继续执行后序代码
} catch (要捕获的异常类型 e) {
// 对异常进行处理
} finally {
// 此处代码一定会被执行到
}
// 后序代码
// 当异常被捕获到时,异常就被处理了,这里的后序代码一定会执行
// 如果捕获了,由于捕获时类型不对,那就没有捕获到,这里的代码就不会被执行
//注意:try中的代码可能会抛出异常,也可能不会
举个栗子:
public class TestDemo2 {
public static void main(String[] args) {
int[] array = {1,2,3};
try {
array[100] = 0;
} catch (NullPointerException e) {
e.printStackTrace();
System.out.println("捕获到了一个空指针异常");
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
System.out.println("捕获到了一个数组越界异常");
}
System.out.println("其他业务逻辑");
}
}
注意:
-
try
后面的代码块内抛出异常位置之后的代码将不会被执行public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; System.out.println("上面那行出现异常,这行是执行不了的"); } catch (NullPointerException e) { e.printStackTrace(); System.out.println("捕获到了一个空指针异常"); } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); System.out.println("捕获到了一个数组越界异常"); } System.out.println("其他业务逻辑"); } }
-
如果抛出异常类型与
catch
时异常类型不匹配,即异常不会被成功捕获,也就不会被处理,继续往外抛,直到JVM
收到后中断程序.public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0;//发生数组越界异常 System.out.println("上面那行出现异常,这行是执行不了的"); } catch (NullPointerException e) {//空指针异常 e.printStackTrace(); System.out.println("捕获到了一个空指针异常"); } System.out.println("其他业务逻辑"); } } //try语句中发生的是数组越界异常,而我们的catch里面是空指针异常,数组越界异常就不能被捕捉到.最后一行的其他业务逻辑也就不能被打印了
-
try
中可能会抛出多个不同的异常对象,则必须用多个catch
来捕获public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; } catch (NullPointerException e) { e.printStackTrace(); System.out.println("捕获到了一个空指针异常"); } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); System.out.println("捕获到了一个数组越界异常"); } System.out.println("其他业务逻辑"); } }
如果多个异常的处理方式是完全相同, 也可以写成这样:
public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; } catch (NullPointerException | ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } System.out.println("其他业务逻辑"); } }
如果异常之间具有父子关系,一定是子类的异常在前
catch
,父类的异常在后面catch
,否则语法错误:public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; } catch (Exception e) { e.printStackTrace(); } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } } }
正确写法:
public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } catch (Exception e) {//Exception可以捕捉到所有异常,所以我们可以拿它来兜底 e.printStackTrace(); } } }
-
可以通过一个
catch
捕获所有的异常,即多个异常,一次捕获(不推荐)public class TestDemo2 { public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; } catch (Exception e) {//Exception可以捕捉到所有异常,所以我们可以拿它来兜底,但是不能只有Exception e.printStackTrace(); } } }
-
一个
try
里面只能同时处理一个异常public class TestDemo2 { public static void func(int a) throws RuntimeException { if(a == 10) { throw new RuntimeException("a == 10"); } } public static void main(String[] args) { int[] array = {1,2,3}; try { array[100] = 0; func(10); } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } catch (RuntimeException e) { e.printStackTrace(); } } }
-
编译时候的异常必须处理!运行时的异常可以不处理,交给
JVM
来处理~程序员处理了异常,就没啥事了.程序猿没处理,
JVM
就帮我们处理了
2.3.3 finally
在写程序时,有些特定的代码,不论程序是否发生异常,都需要执行,比如程序中打开的资源:网络连接、数据库连接、IO
流等,在程序正常或者异常退出时,必须要对资源进进行回收。另外,因为异常会引发程序的跳转,可能导致有些语句执行不到,finally
就是用来解决这个问题的。
语法:
try {
// 可能会发生异常的代码
} catch (异常类型 e) {
// 对捕获到的异常进行处理
} finally {
// 此处的语句无论是否发生异常,都会被执行到
}
// 如果没有抛出异常,或者异常被捕获处理了,这里的代码也会执行
举个栗子:
public static void main(String[] args) {
int[] array = {1,2,3};
try {
array[100] = 0;
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
} finally {
System.out.println("finally里面的这句话一定会被执行");
}
}
那么有一个问题:既然 finally
和 try-catch-finally
后面的代码都会执行,那为什么还要有 finally
呢?
finally
一般是用来做资源清理的扫尾操作的
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
try {
int a = scanner.nextInt();
System.out.println(10/a);
} catch (ArithmeticException e) {
System.out.println("捕捉到了算术异常");
e.printStackTrace();
} finally {
scanner.close();//正常我们使用scanner就需要在最后close的
System.out.println("finally语句一定会被执行,所以这里面会执行一些关闭资源的语句");
}
}
当我们只有一个资源进行中的时候,我们也可以这么写
public static void main(String[] args) {
try(Scanner scanner = new Scanner(System.in)) {
int a = scanner.nextInt();
System.out.println(10/a);
} catch (ArithmeticException e) {
System.out.println("捕捉到了算术异常");
e.printStackTrace();
} finally {
//这种情况就可以不用关闭资源了
System.out.println("finally语句一定会被执行,所以这里面会执行一些关闭资源的语句");
}
}
那么我们看这样一道题:
public static int func1() {
try{
return 10;
} finally {
return 20;
}
}
public static void main(String[] args) {
System.out.println(func1());
}
输出结果是多少?
2.4 异常的处理流程
关于 “调用栈”
方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在
JVM
中有一块内存空间称为 “虚拟机栈” 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用e.printStackTrace();
的方式查看出现异常代码的调用栈.
如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递.如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM
处理, 程序就会异常终止
//这种就是抛出异常,有捕捉的
public static void func3(int a) throws ArithmeticException {
if(a == 10) {
throw new ArithmeticException("a == 10");
}
}
public static void main(String[] args) {
try {
func3(10);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
//这种就是我们没有捕获异常,JVM帮我们直接把程序终止掉了
public static void func3(int a) throws ArithmeticException {
if(a == 10) {
throw new ArithmeticException("a == 10");
}
}
public static void main(String[] args) {
func3(10);
System.out.println("这句话因为我们没有处理异常,JVM会帮我们直接把程序终止,这句话就执行不到了");
}
2.5 异常处理流程总结
- 程序先执行
try
中的代码 - 如果
try
中的代码出现异常, 就会结束try
中的代码, 看和catch
中的异常类型是否匹配. - 如果找到匹配的异常类型, 就会执行
catch
中的代码 - 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
- 无论是否找到匹配的异常类型,
finally
中的代码都会被执行到(在该方法结束之前执行). - 如果上层调用者也没有处理的了异常, 就继续向上传递.
- 一直到
main
方法也没有合适的代码处理异常, 就会交给JVM
来进行处理, 此时程序就会异常终止.
三、自定义异常类
在一个大型项目中,可以自定义新的异常类型,但是,保持一个合理的异常继承体系是非常重要的。
语法:
-
自定义一个异常类,继承
Exception
或者RunTimeException
继承自
Exception
的异常默认是受查异常
继承自RuntimeException
的异常默认是非受查异常. -
在这个异常类当中,实现一个带有一个参数(
String
)的构造方法,参数代表报错原因
//用户名错误,我们设计出来的异常类
public class UserNameError extends RuntimeException {
public UserNameError(String message) {
super(message);
}
}
//密码错误,我们设计出来的异常类
public class PasswordError extends RuntimeException {
public PasswordError(String message) {
super(message);
}
}
例如,我们实现一个简易的用户登录功能
我们先来自定义异常类
//用户名错误,我们设计出来的异常类
public class UserNameError extends RuntimeException {
public UserNameError(String message) {
super(message);
}
}
//密码错误,我们设计出来的异常类
public class PasswordError extends RuntimeException {
public PasswordError(String message) {
super(message);
}
}
再来写我们的测试逻辑文章来源:https://www.toymoban.com/news/detail-816775.html
public class Login {
private String userName = "admin";
private String pass = "123456";
public void LoginInfor(String userName,String password) throws UserNameError,PasswordError {
if(!this.userName.equals(userName)) {//不相等的情况
throw new UserNameError("用户名错误");
}
if(!this.pass.equals(password)) {//不相等的情况
throw new PasswordError("密码错误");
}
//走到这里,代表登陆成功
System.out.println("登陆成功");
}
public static void main(String[] args) {
try {
Login login = new Login();
login.LoginInfor("admin","avd");
} catch (UserNameError e) {
System.out.println("用户名错误");
e.printStackTrace();
} catch (PasswordError e) {
System.out.println("密码错误");
e.printStackTrace();
}
}
}
至此 , Java 基础部分已经分享完毕 , 多线程以及文件操作等难度稍微有点高的内容我会放到 JavaWeb 阶段跟大家再来分享
文章来源地址https://www.toymoban.com/news/detail-816775.html
到了这里,关于不就是Java吗之 认识异常的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!