- 异常概述 2. 举例 3. 异常的处理机制 4. final finally finalize区别 5. 自定义异常(开发中常用) 6. 总结异常中的关键字
异常处理(6)
1. 异常概述
定义
程序执行过程中由代码产生的一种错误。
异常在java中以类的形式存在,每一个异常类都可以创建异常对象。
作用
增强程序的健壮性。
体系结构
Throwable类是Java异常体系结构中的根类,有Error类(系统错误类)和Exception类(异常类)。
分类别称
编译时异常:
受检异常:CheckedException
受控异常Exception的直接子类(除了RuntimeException类及其子类)
编译时异常,要求程序员在编写程序阶段必须预先对这些异常进行处理,如果不处理编译器报错,因此得名编译时异常。
运行时异常:
未受检异常:UnCheckedException
非受控异常RuntimeException类及其子类和Error类属于Runtime异常
所有异常都是在运行阶段发生的。因为只有程序运行阶段才可以 new对象。因为异常的发生就是new异常对象。
编译时异常和运行时异常的区别?
编译时异常发生概率较高,需要在运行之前对其进行预处理。
运行时异常发生概率较低,没必要提前进行预处理。
2. 举例
public class ExceptionTest01 {
public static void main(String[] args) {
int a = 10;
int b = 0;
//1
int c = a / b;
System.out.println(a + “/” + b + “=” + c);
//2
System.out.println(100 / 0);
}
}
实际上JVM在执行到1的时候,会new异常对象:
new ArithmeticException(“/ by zero”);
并且JVM将new的异常对象抛出,打印输出信息到控制台了。
运行到2也会创建一个:ArithmeticException类型的异常对象。
public class ExceptionTest02 {
public static void main(String[] args) {
System.out.println(100 / 0);
// 这里的HelloWorld没有输出,没有执行。
System.out.println(“Hello World!”);
}
}
程序执行到System.out.println(100 / 0);
此处发生ArithmeticException 异常,底层 new 了一个ArithmeticException异常对象,然后抛出了。
由于是 main方法 调用了100 / 0,所以这个异常ArithmeticException抛给了main方法。
main方法没有处理,将这个异常自动抛给了 JVM。JVM最终终止程序的执行。
此时System.out.println(“Hello World!”);并不会执行。
注意:
ArithmeticException 继承 RuntimeException,属于运行时异常。在编写程序阶段不需要对这种异常进行预先的处理。
3. 异常的处理机制
3.1 声明抛出异常子句 throws
在方法声明的位置上使用 throws 关键字抛出,throws上报给方法调用者(推卸责任:调用者知道)
public class ExceptionTest04 {
public static void main(String[] args) throws ClassNotFoundException {
doSome();
}
public static void doSome() throws ClassNotFoundException{
System.out.println(“doSome!!!”);
}
}
3.2 异常的捕获与处理 try…catch
这个异常不会上报,自己把这个事儿处理了。
public class ExceptionTest04 {
public static void main(String[] args) {
try {
doSome();
} catch (ClassNotFoundException e) {
e.printStackTrace();//这个分支中可以使用e引用,e引用保存的内存地址是那个new出来异常对象的内存地址。
}
}
public static void doSome() throws ClassNotFoundException{
System.out.println(“doSome!!!”);
}
}
注意:
- 只要异常没有捕捉,采用上报的方式,此方法的 后续代码不会执行。
- try语句块中的某一行出现异常,该行 后面的代码不会执行。
try…catch捕捉异常之后,后续代码可以执行。 - 异常发生之后,如果我选择了上抛,抛给了我的调用者,调用者需要对这个异常继续处理,那么调用者处理这个异常同样有两种处理方式。
- 一般不建议在main方法上使用throws,因为这个异常如果真正的发生了,一定会抛给JVM。JVM只有终止。
- 一般main方法中的异常建议使用try…catch进行捕捉。
3.3 抛出异常 throw
throw new Exception(“异常信息”);
3.4 深入try…catch
- catch后面的小括号中的类型可以是 具体的异常类型,也可以是该异常类型的 父类型。
- catch可以写多个。建议catch的时候,精确的一个一个处理。这样有利于程序的调试。
- catch写多个的时候,从上到下,必须遵守 从小到大。
try {
FileInputStream fis = new FileInputStream(“D:\Javabean.docx”);
} catch(FileNotFoundException e) {
System.out.println(“文件不存在!”);
}
等同于
try {
FileInputStream fis = new FileInputStream(“D:\Javabean.docx”);
} catch(Exception e) {// 多态:Exception e = new FileNotFoundException();
System.out.println(“文件不存在!”);
}
try {
FileInputStream fis = new FileInputStream(“D:\Javabean.docx”);
fis.read();
} catch(IOException e){
System.out.println(“读文件报错了!”);
} catch(FileNotFoundException e) {
System.out.println(“文件不存在!”);
}
- JDK8的新特性:
catch() 异常间可以自小到大用 | 分割
try {
//创建输入流
FileInputStream fis = new FileInputStream(“D:\Javabean.docx”);
// 进行数学运算
System.out.println(100 / 0); // 这个异常是运行时异常
} catch(FileNotFoundException | ArithmeticException | NullPointerException e) {
System.out.println(“文件不存在?数学异常?空指针异常?都有可能!”);
}
-
异常两个重要方法
String getMessage() 返回异常的详细消息字符串
void printStackTrace() 追踪堆栈异常信息(采用异步线程) -
finally字句
-
在finally子句中的代码是最后执行的,并且是一定会执行的,即使try语句块中的代码出现了异常。
-
finally子句必须和try一起出现,不能单独编写。
-
通常在finally语句块中完成 资源的释放/关闭。
public class ExceptionTest10 {
public static void main(String[] args) {
FileInputStream fis = null; // 声明位置放到try外面。这样在finally中才能用。
try {
fis = new FileInputStream(“D:\Javabean.docx”);
String s = null;
// 这里一定会出现空指针异常!
s.toString();
System.out.println(“hello world!”);
// 流使用完需要关闭,因为流是占用资源的。
// 即使以上程序出现异常,流也必须要关闭!
// 放在这里有可能流关不了。
//fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch(IOException e){
e.printStackTrace();
} catch(NullPointerException e) {
e.printStackTrace();
} finally {
System.out.println(“hello 浩克!”);
// 流的关闭放在这里比较保险。
// finally中的代码是一定会执行的。
// 即使try中出现了异常!
if (fis != null) { // 避免空指针异常!
try {
// close()方法有异常,采用捕捉的方式。
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
- try和finally联用,没有catch
public class ExceptionTest11 {
public static void main(String[] args) {
try {
System.out.println(“try…”);
return;
} finally {
System.out.println(“finally…”);
}
// 这里不能写语句,因为这个代码是无法执行到的。
//System.out.println(“Hello World!”);
}
}
以下代码的执行顺序:
- 先执行try…
- 再执行finally…
- 最后执行 return (return语句只要执行方法必然结束。)
注意:
try不能单独使用。
try finally可以联合使用。
放在finally语句块中的代码是一定会执行的
- finally子句失效
System.exit(0); 只有这个可以治finally。
java语法规则(有一些规则是不能破坏的,一旦这么说了,就必须这么做!):
java中有一条这样的规则:
- 方法体中的代码必须遵循自上而下顺序依次逐行执行(亘古不变的语法!)
- return语句一旦执行,整个方法必须结束(亘古不变的语法!)
4. final finally finalize区别
细节 | |
---|---|
final关键字 | final修饰的类无法继承;final修饰的方法无法覆盖;final修饰的变量不能重新赋值。 |
finally关键字 | finally 和try一起联合使用。finally语句块中的代码是必须执行的。 |
finalize标识符 | 是一个Object类中的方法名。这个方法是由垃圾回收器GC负责调用的。 |
5. 自定义异常(开发中常用)
SUN公司提供的JDK内置的异常肯定是不够的用的。在实际的开发中,有很多业务,这些业务出现异常之后,JDK中都是没有的,是和业务挂钩的,因此需要自定义异常。
5.1 自定义异常步骤
第一步:编写一个类继承 Exception 或者 RuntimeException.
第二步:提供两个构造方法,一个无参数的,一个带有String参数的。
自定义异常:栈操作异常
public class StackOperationException extends Exception{
public MyStackOperationException(){
}
public MyStackOperationException(String s){
super(s);
}
}
5.2 方法覆盖时遗留的问题
重写之后的方法不能比重写之前的方法抛出更多(更宽泛)的异常,可以更少。
class Animal {
public void doSome(){}
public void doOther() throws Exception{}
}
class Cat extends Animal {
// 编译正常。
public void doSome() throws RuntimeException{}
// 编译报错。
public void doSome() throws Exception{}
// 编译正常。
public void doOther() {}
// 编译正常。
public void doOther() throws Exception{}
// 编译正常。
public void doOther() throws NullPointerException{}
}
注意:
一般不会这样考虑,方法覆盖复制一份,然后重写就好了。
6. 总结异常中的关键字
异常捕捉:
try
catch
finally
throws 在方法声明位置上使用,表示上报异常信息给调用者。
throw 手动抛出异常
public void pop() throws StackOperationException {
if(index < 0){
throw new MyStackOperationException(“弹栈失败,栈已空!”);//手动抛出异常
}
}
该方法index < 0时手动抛出异常,然后在方法里没有处理,上报给调用者,让调用者处理!