Java-异常
异常
- 就是程序不正常的情况
java中程序的异常：Throwable
- Error:严重的问题，这样的情况，我们一般不做处理，因为这样的问题一般不是程序本身带来问题，而是外界导致。
- Exception:
- 1.编译时期异常：除了RuntimeException以外的异常都是编译时期异常，这样的异常必须做处理，如果不处理程序无法运行，编译无法通过
- 2.运行时期异常：RuntimeException 这样的 问题我们可以不做处理，因为这是你自己的问题，通常情况下，出现这样的问题一般都是因为代码的逻辑不够严谨导致的。
出现问题后，如果我们没有做任何处理，JVM会提供一个默认的处理方式，可以看到出现了什么异常，出现异常的信息，以及出现问题的代码
public class ExceptionDemo1 {
public static void main(String[] args) {
//运行时期异常
int[] arr = {11,22,33,44,55};
System.out.println(arr[1]);
System.out.println(arr[5]);
System.out.println("hello");
}
}
异常处理方案
- 1、try…catch…finally
- 2、throws
格式：
try…catch…finally处理格式：
try{
可能会出现问题的代码;
}catch(异常的类名 变量名){
针对出现的问题做处理;
}finally{
一般情况下，这里写释放资源;
}
变形格式：
try{
可能会出现问题的代码;
}catch(异常的类名 变量名){
针对出现的问题做处理;
}
注意点
- 1、try里面的代码如果出现问题，try里面的代码就会停在那一行，然后JVM会自动识别是什么问题，去catch匹配对应的异常，匹配到后执行对应的处理方式（catch大括号中的代码）,如果没有匹配到，JVM会执行默认的处理方式，而默认的处理方式会将程序停止，后面的代码都不会执行
- 2、try里面的代码越少越好，确定不会出错的代码就不要try里面写了。
- 3、catch里面必须要有内容，哪怕就写了一个简单输出语句提示
public class ExceptionDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 0;
//方式一：提前做一个判断
if(b != 0){
System.out.println(a/b);
}else{
System.out.println("被除数不能为0！");
}
//方式二：使用try。。。catch。。。
try {
System.out.println(a/b);
} catch (Exception e) {
e.printStackTrace();
// System.out.println("你的除数为零了！");
}
//当对上面的异常进行处理之后异常之后的程序依旧会执行
System.out.println("hello....");
}
}
处理一个异常和处理多个异常
try{
...
}catch(){
...
}catch(){
...
}
注意事项
- 1、多个异常使用try..catch处理的时候，catch可以写一个，里面写最大的父类Exception,但是如果这么写了，try里面无论出现什么错误，都会匹配到这里的catch，这样的做的话，所有的问题处理方式都是一种处理，没法区分，不推荐这么做
- 2、多个catch之间可以是继承关系，但是，要把父类的catch写在最后，因为出现问题匹配catch的顺序是自上而下的。
- 3、JDK1.7之后出现了处理异常的新方案：
try{
放上可能会出现问题的代码;
}catch(异常类名1|异常类名2|异常类名3|... 变量名){
处理问题的代码;
}
注意：
- 1）新特性处理的方式并不太好，因为多种异常的处理方式统一是一种
- 2）新特性的处理catch中的异常只能是平级关系，不能是继承关系
public class ExceptionDemo3 {
public static void main(String[] args) {
//编译时期异常
String s = "2022-04-06 14:35:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// try {
// Date date = sdf.parse(s);
// System.out.println(date);
// }catch (ParseException pe){
// System.out.println("日期转换出错了！！！");
// }
//
// int[] arr = {11,22,33,44,55};
// try {
// System.out.println(arr[5]);
// }catch (ArrayIndexOutOfBoundsException aiob){
// System.out.println("取了不该取的索引");
// }
System.out.println("===============================================");
//第二种处理方式：写一个try，多个catch
// try {
// Date date = sdf.parse(s);
// int[] arr = {11, 22, 33, 44, 55};
// System.out.println(arr[5]);
// }catch (ParseException ae){
// System.out.println("日期处理格式");
// }catch (Exception ae){
// System.out.println("取了不该取的索引");
// }
System.out.println("===============================================");
//JDK1.7try..catch处理新方式
try {
Date date = sdf.parse(s);
int[] arr = {11, 22, 33, 44, 55};
System.out.println(arr[5]);
}catch (ParseException|ArrayIndexOutOfBoundsException e){
System.out.println("出错啦！！");
}
System.out.println("你好！！！");
}
}
- 分析问题： 在前面案例中，我们处理异常的方式都是输出一句话，告诉我们出了什么问题，但是呢，对比发现，并没有默认处理方式来的直接和清楚try..catch..的处理过程是，当try中的代码出现了问题的时候，JVM会帮助我们生成一个异常对象，然后把这个对象跑出来，与catch中的
类型进行匹配，如果匹配到了，就走对应的处理方式。
异常中需要了解的几个方法：
- 1、getMessage()
获取异常信息，返回字符串。- 2、toString()
获取异常类名和异常信息，返回字符串。- 3、printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void
public class ExceptionDemo4 {
public static void main(String[] args) {
String str= "2020-04-05 19:23:45";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
// try {
// Date parse = simpleDateFormat.parse(str);
// }catch (ParseException e) {
// System.out.println("日期转换异常！");
// String message = e.getMessage();
// System.out.println(message); //Unparseable date: "2020-04-05 19:23:45" 无法解析时间
//
// String s = e.toString();
// System.out.println(s); //java.text.ParseException: Unparseable date: "2020-04-05 19:23:45"
// //此对象的类的name（全路径名）
// //": "(冒号和一个空格)
// //调用此对象中的getLocalizedMessage()方法，底层调用的还是getMessage()方法。
// }
try {
Date parse = simpleDateFormat.parse(str);
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println("你好！");
}
}
异常第二种解决办法：throws
- 有些时候，我们可以对异常去做处理，但是呢，有些时候，我们根本就没有权限去处理这些异常。 或者说， 我们处理不了，就不处理了，交给更高权限的去处理。为了解决这样出错的问题，Java针对这种情况，就提供了另一种处理方案：抛出
格式
- throws 异常类名
注意：这个格式必须跟在方法的小括号后面，大括号前面。
注意：
- 1、尽量不要在main方法上面抛出，因为main方法是由JVM调用的，如果出问题了，依旧是走默认的处理方式，
而默认的处理方式，会将程序终止，后续代码不会执行，推荐能try..catch就try..catch
（为了上课方便，后面的课程我就大部分在方法上抛出了）- 2、编译时期异常抛出，调用者必须要做处理，因为不做就没办法通过编译，就无法运行
- 3、运行时期异常抛出，调用者可以不做处理，但是运行出了问题，程序终止，后续代码不会执行（推荐运行前检查代码逻辑，其次可以像处理编译时期异常一样try..catch）
throw: 在方法内部抛出，后面跟上具体的异常对象
面试题
- throws:
用在方法的声明后面，后面跟的是异常的类名
异常的类名可以是多个，多个类名之间使用逗号隔开
表示将异常抛出，交给调用者去处理
throws表示的是一种可能性，并不一定会发生这些异常
- throw
用在方法的内部，后面跟的是异常的对象;
只能是一个对象,不能抛出多个
表示抛出异常，由方法内部的语句体去做处理
throw表示的是方法内部一定会出现某种异常，是确定的。
public class ExceptionDemo5 {
public static void main(String[] args){
// try {
// function();
// } catch (ParseException e) {
// e.printStackTrace();
// }catch(ArithmeticException ae){
// ae.printStackTrace();
// }
try {
function3();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("你好！");
}
public static void function3(){
int q = 10;
int p = 0;
if(p != 0){
System.out.println(q/p);
}else{
// System.out.println("除数为0");
throw new ArithmeticException(); //确定一定会出问题，抛出一个对象
}
}
// public static void function() throws ParseException,ArithmeticException{
// String str = "2020-04-06 16:08:00";
// SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date date = simpleDateFormat.parse(str);
//
// int a = 10;
// int b = 0;
// System.out.println(a/b);
}
面试题：
- finally,final,finalize他们三个你认识吗，他们什么什么区别？
回答：都认识，但是他们三个之间没有任何关系，只是长得像罢了。finally是在异常处理中遇到，一般是用于释放资源的
final是java中的一个关键字，他可以修饰类，成员变量，成员方法，修饰类，类不能被继承，修饰成员变量，
变量变常量，修饰成员方法，方法不能被重写；finalize是Object类中的一个方法名，该方法是用于垃圾回收的
但是什么时候回收不确定。
public class ExceptionDemo7 {
public static void main(String[] args) {
System.out.println(fun()); // a =
}
public static int fun(){
int a = 20;
int b = 0;
try {
a = 30;
System.out.println(a/b);
a = 40; // 这一行肯定不会执行
}catch (ArithmeticException ae){
a = 60;
// ae.printStackTrace();
return a;
//当程序走到这里的时候，方法其实已经有了一个返回值路径，返回的就是60。
//但是程序此刻还没有结束，所以依旧会走finally中的语句
}finally {
a = 50;
System.out.println(a);
// return a;
}
return a; // 这里其实是为了语法的正确，加了return
}
}
继承中的异常
- 1、子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
- 2、如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
- 3、如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
自定义异常
- java中不可能把所有的情况都考虑到，所以在开发中，可能会自己定义异常
但是我们，我自己随便写的一个类它仅仅是普通的类，不是异常类，于是需要继承Exception
或者RuntimeException
MyException
public class MyException extends Exception{
public MyException() {
}
public MyException(String message) {
super(message);
}
}
抛出 MyException
package com.shujia.java.day19;
import java.util.Scanner;
/**
* @author xiaohu
* @date 2021/08/14
*/
public class ExceptionStudentDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生的成绩：");
int score = sc.nextInt();
Teacher t = new Teacher();
try{
t.check(score);
}catch (MyException me){
me.printStackTrace();
}
}
}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！