异常处理
什么是异常
**异常定义:**导致程序的正常流程被中断的事件,叫异常。
-
文件不存在异常FileNotFoundException
如果要打开d盘中的某个文件,这个文件可能是不存在的,Java中通过new FileInputStream(f)试图打开某文件,就有可能抛出文件不存在异常FileNotFoundException
如果不处理该异常,就会有编译错误
-
File类:Java文件类 以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除、重命名文件等。 File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。
处理
异常常见处理手段: try,catch,finally,throws
try catch
- 将可能抛出FileFoundExcpetion文件不存在异常的代码放在try里
- 如果文件存在,就会顺序往下执行,并且不执行catch块中的代码
- 如果文件不存在,try里的代码会立即终止,程序流程会运行到对应的catch块中
- e.pirntStackTrace();会打印出方法的调用痕迹,打印出控制台中的红色字体,如此例,会打印出异常开始于Exception的第13行,就这样便于定位和分析哪里出了异常
import java.io.*;
public class TestException {
public static void main(String[] args) {
File f = new File("d:/csgo.exe");
try {//监控区域
System.out.println("试图打开d:/csgo.exe");
new FileInputStream(f);
System.out.println("成功打开");
}catch(FileNotFoundException e){//捕获异常
System.out.println("d:/csgo.exe不存在");
e.printStackTrace();//打印异常错误
}
}
}
使用异常的父类进行catch
FileNotFoundException是Exception的子类,使用Exception也可以catch住FileNotFoundExcepti
import java.io.*;
public class TestException {
public static void main(String[] args) {
File f = new File("d:/csgo.exe");
try {
System.out.println("试图打开d:/csgo.exe");
new FileInputStream(f);
System.out.println("成功打开");
}catch(Exception e){
System.out.println("d:/csgo.exe不存在");
e.printStackTrace();
}
}
}
多异常捕捉方法
- 一段代码中抛出多种异常,下面这段代码中会抛出文件不存在异常 FileNotFoundException 和 解析异常ParseException
new FileInputStream(f);
分别进行catch
catch (FileNotFoundException e) {
System.out.println("d:/csgo.exe不存在");
e.printStackTrace();
} catch (ParseException e) {
System.out.println("日期格式解析错误");
e.printStackTrace();
}
Java中多个catch的捕获顺序
对于try…catch捕获异常的形式来说,对于异常的捕获,可以有多个catch。对于try里面发生的异常,他会根据发生的异常和catch里面的进行匹配(怎么匹配,按照catch块从上往下匹配),当它匹配某一个catch块的时候,他就直接进入到这个catch块里面去了,后面在再有catch块的话,它不做任何处理,直接跳过去,全部忽略掉。如果有finally的话进入到finally里面继续执行。换句话说,如果有匹配的catch,它就会忽略掉这个catch后面所有的catch
提示:在写异常处理的时候,一定要把异常范围小的放在前面,范围大的放在后面,Exception这个异常的根类一定要放在最后一个catch里面,如果放在前面或者中间,任何异常都会和Exception匹配的,就会报已捕获到…异常的错误。
- 将多个异常放在一个catch里一起捕捉
catch (FileNotFoundException | ParseException e) {
}
这种捕捉从JDK7开始支持,优点是捕捉的代码更紧凑;缺点是一旦发生异常,不能确定是哪种异常需要通过instanceof进行判断具体的异常类型
if (e instanceof FileNotFoundException)
System.out.println("d:/LOL.exe不存在");
if (e instanceof ParseException)
System.out.println("日期格式解析错误");
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestException {
public static void main(String[] args) {
File f = new File("d:/LOL.exe");
try {
System.out.println("试图打开d:/LOL.exe");
new FileInputStream(f);
System.out.println("成功打开");
SimpleDateFormat sdf=newSimpleDateFormat("yyyy-MM-dd");
Date d = sdf.parse("2016-06-03");
} catch (FileNotFoundException | ParseException e) {
if (e instanceof FileNotFoundException)
System.out.println("d:/LOL.exe不存在");
if (e instanceof ParseException)
System.out.println("日期格式解析错误");
e.printStackTrace();
}
}
}
finally
无论是否出现异常,finally中的代码都会被执行
finally可以不要,但是遇到IO流资源关闭需要使用finally
import java.io.*;
public class TestException {
public static void main(String[] args) {
File f = new File("d:/csgo.exe");
try {
System.out.println("试图打开d:/csgo.exe");
new FileInputStream(f);
System.out.println("成功打开");
}catch(FileNotFoundException e){
System.out.println("d:/csgo.exe不存在");
e.printStackTrace();
}finally{//处理善后和工作
System.out.println("无论文件是否存在, 都会执行的代码");
}
}
}
throw
主动抛出异常一般在方法中使用
import java.io.*;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
public class TestException {
public static void main(String[] args) {
int a = 1;
int b = 0;
try{
if(b==0){ //throw
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
} catch(Exception e){
System.out.println("Exception");
e.printStackTrace();
} catch(Throwable e){
System.out.println("Throwable");
e.printStackTrace();
}
}
}
package com.situ.test03;
import java.io.*;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
public class TestException {
public void test(int a,int b) {
if(b==0){ //throw
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
}
public static void main(String[] args) {
new TestException().test(1,0);
}
}
/*
* public void test(int a,int b) {
if(b==0){ //throw
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
}
*/
import java.io.*;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
public class TestException {
public void test(int a,int b) {
if(b==0){ //throw
throw new ArithmeticException();//主动抛出异常
}
}
public static void main(String[] args) {
new TestException().test(1,0);
}
}
是否有方法体System.out.println(a/b); 两者都会输出相同的结果
假如在这方法中处理不了这个异常。方法上抛出异常
import java.io.*;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
public class TestException {
public static void main(String[] args) {
try{
new TestException().test(1,0);
}catch(ArithmeticException e){
e.printStackTrace();
}
}
public void test(int a,int b) throws ArithmeticException{
if(b==0){ //throw
throw new ArithmeticException();//主动抛出异常
}
}
}
throws
考虑如下情况:
主方法调用method1
method1调用method2
method2中打开文件
method2中需要进行异常处理
但是method2不打算处理,而是把这个异常通过throws抛出
那么method1就会接到该异常。 处理办法也是两种,要么是try catch处理掉,要么也是抛出去。
method1选择本地try catch住 一旦try catch住了,就相当于把这个异常消化掉了,主方法在调用method1的时候,就不需要进行异常处理了
package exception;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class TestException {
public static void main(String[] args) {
method1();
}
private static void method1() {
try {
method2();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void method2() throws FileNotFoundException {
File f = new File("d:/LOL.exe");
System.out.println("试图打开 d:/LOL.exe");
new FileInputStream(f);
System.out.println("成功打开");
}
}
throw和throws的区别
throws与throw这两个关键字接近,不过意义不一样,有如下区别:
- throws 出现在方法声明上,而throw通常都出现在方法体内。
- throws 表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某个异常对象。
Throwable
Throwable是类,Exception和Error都继承了该类
所以在捕捉的时候,也可以使用Throwable进行捕捉
用户的自定义异常
//自定义一个异常
public class MyException extends Exception{
@Override
public String toString() {
return "这是一个自定义异常";
}
}
//使用自定义的异常
public void method2(int count) throws MyException {//抛出异常
if(count<=15){
//引发了一个异常 主动引发以后,方法必须抛出异常
throw new MyException();
}
}
@Test
public void test45(){
try {
method2(0);
} catch (MyException e) {
e.printStackTrace();
}
}
//自定义异常
//可以继承 Throwables 或是 Exception,一般继承Exception
public class MyException entends Exception{
}
异常分类
异常可分为可查异常、运行时异常和错误3种,其中,运行时异常和错误又叫非可查异常
可查异常(CheckedException)
可查异常即必须进行处理的异常,要么try catch住,要么向外抛,谁调用谁处理,比如 FileNotFoundException如果不处理,编译器,就不让你通过
运行时异常(RuntimeException)
运行时异常即不是必须进行try catch的异常
常见的运行时异常:
除数不能为0异常:ArithmeticException 、下标越界异常:ArrayIndexOutOfBoundsException 、空指针异常:NullPointerException
在编写代码的时候,依然可以使用try catch throws进行处理,与可查异常不同之处在于,即便不进行try catch,也不会有编译错误 Java之所以会设计运行时异常的原因之一,是因为下标越界,空指针这些运行时异常太过于普遍,如果都需要进行捕捉,代码的可读性就会变得很糟糕。
错误(Error)
错误Error,指的是系统级别的异常,通常是内存用光了
在默认设置下,一般java程序启动的时候,最大可以使用16m的内存
如例不停的给StringBuffer追加字符,很快就把内存使用光了。抛出OutOfMemoryError
与运行时异常一样,错误也是不要求强制捕捉的
三种分类
- 错误
- 运行时异常
- 可查异常
空指针异常:NullPointerException
在编写代码的时候,依然可以使用try catch throws进行处理,与可查异常不同之处在于,即便不进行try catch,也不会有编译错误 Java之所以会设计运行时异常的原因之一,是因为下标越界,空指针这些运行时异常太过于普遍,如果都需要进行捕捉,代码的可读性就会变得很糟糕。
错误(Error)
错误Error,指的是系统级别的异常,通常是内存用光了
在默认设置下,一般java程序启动的时候,最大可以使用16m的内存
如例不停的给StringBuffer追加字符,很快就把内存使用光了。抛出OutOfMemoryError
与运行时异常一样,错误也是不要求强制捕捉的
三种分类
1. 错误
2. 运行时异常
3. 可查异常