Java|异常
- 异常的概述和分类
- RuntimeException(运行期异常)
– JVM默认处理方式
– 手动捕获异常:try…catch - finally关键字的特点及作用
–面试题1：final,finally和finalize的区别
–面试题2：如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后 - 编译期异常
- 自定义异常
- Throwable
- throw和throws
1.异常的概述和分类
数据在传输的时候，有肯能会出现一些问题，那么我们需要对这些问题进行处理，那Java给我们提供了一套异常的处理机制。
Throwable：Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。
- Error:严重问题
- Exception:一般问题
–RuntimeException（运行期异常）:可以解决，也可以不解决
–非 RuntimeException(编译器异常)：必须解决
2.RuntimeException（运行期异常）
RuntimeException（运行期异常）:发生在程序运行期间，可以解决，也可以不解决，（如果不解决，交有JVM处理）
运行期异常有两种处理方式：JVM默认处理方式和手动捕获异常
2.1JVM默认处理方式
JVM的默认处理方法：
main函数收到这个问题时,有两种处理方式:
- 自己将该问题处理,然后继续运行
- 自己没有针对的处理方式,只有交给调用main的jvm来处理，而jvm有一个默认的异常处理机制,就将该异常进行处理.
int a=1;
int b=0;
System.out.println(a/b);
System.out.println("下面的程序");
输出如下：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo.RuntimeExceptionDemo.MyTest1.main(MyTest1.java:12)
在上面的代码中，JVM的处理流程是：打印该异常的异常信息，退出JVM并且System.out.println(“下面的程序”)这行不会执行。
2.2手动捕获异常
try…catch
try…catch的处理格式：
try {
//可能会出现问题的代码
}catch (异常名 变量){
//处理方案
//catch里面不能做空处理，即便你最简单写一条输出语句，提醒一下都行，不要做空处理
}catch (异常名 变量){
//处理方案
}catch (异常名 变量){
//处理方案
}...
注意事项
1.try中的代码越少越好
2.catch中要做处理,哪怕是一条输出语句也可以.(不能将异常信息隐藏)
3.多个异常类，如果是平级关系，在前在后没关系
4.多个异常类，存在继承关系，父类异常要放在后面
一个异常的处理：
try{
//这行代码有可能会出现异常
System.out.println(a/b);
}catch (ArithmeticException e){
//一旦遇到这个异常，怎么去处理
System.out.println("除数为0了");
}
//JVM继续执行下面的代码
System.out.println("下面的程序");
两个异常的处理：
-
每一个写一个try…catch
虽然麻烦，但是两个异常都可以显示出来 -
写一个try…catch…catch
只能显示出一个异常
int a = 1;
int b = 0;
int[] arr = {};
try {
System.out.println(a / b);
System.out.println(arr.length);
} catch (NullPointerException e) {
System.out.println("空指针异常");
} catch (ArithmeticException n) {
System.out.println("除数为0");
}
System.out.println("下面的程序");
输出：
除数为0
下面的程序
异常处理快捷键：ctrl+alt+T
自动生成是是一个异常的父类，可以在中间添加更为详细的子类
try {
System.out.println(1 / 0);
} catch (ArithmeticException e){
e.printStackTrace();//打印子类异常的堆栈信息
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("下面的程序");
3.Finally
1.finally的特点：被finally控制的语句体一定会执行(前提 jvm没有停止)
特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
2.finally的作用:用于释放资源，在IO流操作和数据库操作中会见到
finally面试题1：final,finally和finalize的区别
-
final: 是一个状态修饰符, 可以用来修饰类,变量 ,成员方法.
被修饰的类不能被子类继承,
修饰的变量其实是一个常量不能被再次赋值
修饰的方法不能被子类重写 -
finally:用在try…catch…语句中 , 作用: 释放资源 . 特点: 始终被执行(JVM不能退出)
-
finalize: Obejct类中的一个方法,用来回收垃圾
finally面试题2：如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
答：会执行, 在return前
try {
System.out.println(23 / 0);
} catch (Exception e) {
System.out.println("哦,catch了...............");
return ;
}finally {
System.out.println("哦,被执行了..............");
}
//输出：
//哦,catch了...............
//哦,被执行了..............
4.编译期异常
编译期异常：发生在编译期间，非RuntimeException及其子类，编译期异常必须处理
编译期异常，有两种处理方式：
- 将异常抛给调用者，谁调用谁处理，俗称甩锅 throws 关键字在方法上进行抛出，抛给调用者，由调用者去处理
public class MyTest {
public static void main(String[] args) throws ParseException {
parseDateStr0();
}
private static void parseDateStr0() throws ParseException {
String StrDate="2019:07-20";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date parse = simpleDateFormat.parse(StrDate);
}
- 自己捕获处理 try…catch…
public class MyTest {
public static void main(String[] args) throws ParseException {
parseDateStr();
System.out.println("下一个程序");
}
private static void parseDateStr() {
String StrDate="2019:07-20";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
try{
Date parse = simpleDateFormat.parse(StrDate);
System.out.println(parse);
}catch(ParseException e){
e.printStackTrace();
}
}
}
说明：一般在main方法里面，就不要再抛出了，自己捕获处理
public class MyTest2 {
public static void main(String[] args) {
//一般在main方法里面，就不要再抛出了，自己捕获处理
Scanner scanner = null;
try {
String strDate = "2019-07-20";
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.parse(strDate);
scanner = new Scanner(System.in);
int i = scanner.nextInt();
//System.exit(0); //加上这行代码，就不会执行final里面的代码了
} catch (ParseException e) {
e.printStackTrace();
} finally {
//特点：被finally控制的语句体一定会执行(前提 jvm没有停止)
// 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
//作用：用于释放资源，在IO流操作和数据库操作中会见到
System.out.println("finally里面的代码必须执行");
if(scanner!=null){
scanner.close();
}
}
}
}
5.自定义异常
因为在以后的开发过程中,我们可能会遇到各种问题,而JDK不可能针对每一种问题都给出具体的异常类与之对应,为了满足需求,我们就需要自定义异常.
自定义异常必须继承自Exception或者继承自RuntimeException
public class MyTest1 {
public static void main(String[] args) {
// 自定义异常举例：
// 成绩不合法异常 0----100
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的成绩 0---100");
int score = scanner.nextInt();
if(score<=100&&score>=0){
System.out.println(score);
}else{
throw new ScoreException("成绩不合法异常");
}
}
}
public class ScoreException extends RuntimeException {
public ScoreException(String msg) {
super(msg);
}
}
测试：
请输入你的成绩 0---100
-2
Exception in thread "main" ThrowableDemo.SelfDefineExceptionDemo.ScoreException: 成绩不合法异常
at ThrowableDemo.SelfDefineExceptionDemo.MyTest1.main(MyTest1.java:19)
注意事项：
- a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类，或者子类不抛出异常也是可以的。(父亲坏了,儿子不能比父亲更坏)
- b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的。
- c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
栗子：
public class MyTest2 {
public static void main(String[] args) {
}
}
abstract class Father{
public abstract void show() throws ParseException;
}
class Son extends Father{
@Override
public void show() throws ParseException {
new SimpleDateFormat("yyyy").parse("2019");
}
}
如何使用异常处理的总结
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:后续程序需要继续运行就try，后续程序不需要继续运行就throws，如果JDK没有提供对应的异常，需要自定义异常。
6.Throwable
Throwable的几个常见方法
- a:getMessage(): 获取异常信息，返回字符串。
- b:toString(): 获取异常类名和异常信息，返回字符串。
- c:printStackTrace(): 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
7.throw和throws
throw的概述: 在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
throws和throw的区别
a:throws
- 用在方法声明后面，跟的是异常类名
- 可以跟多个异常类名，用逗号隔开
- 表示抛出异常，由该方法的调用者来处理
- throws表示出现异常的一种可能性，并不一定会发生这些异常
b:throw
- 用在方法体内，跟的是异常对象名
- 只能抛出一个异常对象名
- 这个异常对象可以是编译期异常对象,可以是运行期异常对象表示抛出异常，由方法体内的语句处理
- throw则是抛出了异常，执行throw则一定抛出了某种异常
扫一扫
3338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
