异常
写在前面
1、开发过程中的语法错误和逻辑错误不是异常
,如static关键字的s大写了或将<写成了<=
2、Error: Java虚拟机无法解决的严重问题。 如 JVM系统内部错误、 资源耗尽等严重情况。比如: StackOverflowError和OOM。 一般不编写针对性的代码进行处理。
public class ErrorTest {
public static void main(String[] args) {
//1.栈溢出:java.lang.StackOverflowError
//main(args);
//2.堆溢出:java.lang.OutOfMemoryError
//Integer[] arr = new Integer[1024*1024*1024];
int[] arr = new int[0];
//System.out.println(arr[0]);
}
}
一、异常体系结构
java.lang.Throwable
1、java.lang.Error:一般不编写针对性的代码进行处理
2、java.lang.Exception:可以进行处理的异常,包括以下两个方面
(1)编译时异常(checked):IOException里的FileNotFoundException、ClassNotFoundException
(2)运行时异常(unchecked,RuntimeException):NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException(类型转换异常)、NumberFormatException(数值形式异常)
InputMisMatchException(输入不匹配异常)、ArithmeticException(算术异常)。
二、编译时异常
public void test7(){
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
fis.close();
}
二、运行时异常
//ArithmeticException(算术异常)
@Test
public void test6(){
int a = 10;
int b = 0;
System.out.println(a / b);
}
//InputMisMatchException
@Test
public void test5(){
Scanner scan = new Scanner(System.in);
int score = scan.nextInt();
System.out.println(score);
scan.close(); //为防止资源泄露此处应加上关闭键盘输入流
}
//NumberFormatException
@Test
public void test4(){
//String str ="124"; //正确的
//错误的,报异常
String str = "abc";
int num = Integer.parseInt(str);
}
//ClassCastException(类型转换异常)
@Test
public void test3(){
Object obj = new Date();
String str = (String)obj;
}
//IndexOutOfBoundsException
@Test
public void test2(){
//ArrayIndexOutOfBoundsException
// int[] arr = new int[3];
// System.out.println(arr[3]);
//StringIndexOutOfBoundsException
String str = "abc";
System.out.println(str.charAt(3));
}
//NullPointerException
@Test
public void test1(){
int[] arr = null;
System.out.println(arr[3]);
String str = null;
System.out.println(str.charAt(0));
}
三、异常的处理:抓抛模型
1、抓抛模型
(1)过程一:“抛”,程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象,并将此对象抛出。 一旦抛出对象以后,其后的代码就不再执行
关于异常对象的产生:
- 系统自动的生成的异常对象
- 手动的生成一个异常对象,并抛出(throw)。throw new Exception() 或 throw new RuntimeException()
(2)过程二:“抓”:可以理解为异常的处理方式:
- try-catch-finally
- throws,
注意此处的throws是抓异常,而不是抛
2、异常处理的方式一:try-catch-finally的使用
try{
//可能出现异常的代码
}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}catch(异常类型3 变量名3){
//处理异常的方式3
}
...
finally{
//一定会执行的代码
}
说明:
(1)finally是可选的
(2)使用try将可能出现异常代码包装起来
,在执行过程中,一旦出现异常,就会自动生成一个对应异常类的对象,根据此对象的类型,去catch中进行匹配
(3)一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦处理完成,就跳出当前的try-catch结构(在没有写finally的情况)。继续执行其后的代码
(4)catch中的异常类型如果没有子父类关系,则谁声明在上,谁声明在下无所谓
catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面
。否则,报错
(5)常用的异常对象处理的方式:String getMessage和printStackTrace()
(6)在try结构中声明的变量,在出了try结构以后,就不能再使用
(7)try-catch-finally结构可以嵌套
(8)try-catch-finally中finally的使用
- finally是可选的
finally中声明的是一定会被执行的代码
。即使catch中又出现异常了,try中有return语句 catch中有return语句等情况,finally中的代码还是一定会被执行- 像数据库连接、输入输出流、网络编程Socket资源,JVM是不能自动回收的,我们需要自己手动的进行资源的释放。此时的资源释放,就需要声明在finally中。
//该代码只打印finally中的输出语句
@Test
public void test1(){
try{
int a = 10;
int b = 0;
System.out.println(a / b);
}catch(ArithmeticException e){
//e.printStackTrace();
//try{
int[] arr = new int[10];
System.out.println(arr[10]); //像这种catch中有异常未被处理的情况,程序
//执行到这里会直接退出,不会再执行try结构后面的打印语句,但若将输出语句放在
//finally结构中,则即使此处有异常,打印语句也仍会执行
//}catch(ArrayIndexOutOfBoundsException a){
//a.printStackTrace();
//}
e.printStackTrace();
}catch(Exception e){
System.out.println("456");
e.printStackTrace();
}
finally{
System.out.println("我好帅啊");
}
System.out.println("123我好帅啊");
}
体会1:使用try-catch-finally处理编译时异常,使得程序在编译时就不再报错,但是运行时仍可能报错。
相当于我们使用try-catch-finally将一个编译时可能出现的异常,延迟到运行时出现。
体会2:开发中,由于运行时异常比较常见,所以我们通常就
不针对运行时异常
编写
try-catch-finally了。针对于编译时异常,我们一定要考虑异常的处理
。
public class ExceptionTest1 {
@Test
public void tets2(){
try{
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.println((char)data);
data = fis.read();
}
fis.close();
}catch(FileNotFoundException e){ //FileNotFoundException是IOException的子类
//所以要将其写在IOException的前面
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
@Test
public void test1(){
String str = "124";
str = "abc";
int num = 0;
try{
num = Integer.parseInt(str);
System.out.println("hello-----1");
}catch(NullPointerException e){
System.out.println("出现空指针异常了,不要着急");
}catch(NumberFormatException e){ //子类要写在父类的前面
//System.out.println("出现数值转换异常了,不要着急");
//String getMessage();
//System.out.println(e.getMessage());
e.printStackTrace();
}catch(Exception e){
System.out.println("异常");
}
System.out.println(num); //若想使用,就将num的声明放在try结构外面
//又因num有可能不被赋值,所以要提前初始化赋值(属性才有默认初始化值)
System.out.println("hello-----2");
}
}
3、异常处理的方式二:throws + 异常类型
(1)"throws + 异常类型"写在方法的声明处。指明此方法执行时,可能会抛出的异常类型。一旦当方法体执行时,出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常类型时,就会被抛出。异常代码后续的代码,就不再执行!
(2)体会:try-catch-finally:真正的将异常给处理掉了。throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。
(3)开发中如何选择使用try-catch-finally,还是使用throws?
- 如果父类中被重写的方法没有用throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常,则必须使用try-catch-finally方式处理。
- 执行的方法a中,先后又调用了另外的几个方法,这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a中可以考虑使用try-catch-finally方式进行处理。
public class ExceptionTest2 {
public static void main(String[] args){
try {
method2();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
method3();
}
public static void method3(){
try {
method2();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method2() throws FileNotFoundException,IOException{
method1();
}
public static void method1() throws FileNotFoundException,IOException{
File file = new File("hello_1.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
fis.close();
System.out.println("hahahha");
}
}
4、如何自定义异常类
(1)继承于现有的异常结构:RuntimeException、Exception
(2)提供全局常量:serialVersionUID
(3)提供重载的构造器
自定义异常类:
public class MyException extends Exception{
static final long serialVersionUID = -7034897190743266939L;
public MyException(){
}
public MyException(String msg){
super(msg);
}
}
自定义异常类的使用
public class StudentTest {
public static void main(String[] args) {
try {
Student s = new Student();
s.regist(-1001); //此处有异常以后,后面的代码不会再执行
System.out.println(s);
} catch (Exception e) {
//e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
class Student{
private int id;
public void regist(int id) throws MyException{
if(id > 0){
this.id = id;
}else{
//System.out.println("您输入的数据非法");
//手动抛出异常
//抛了一个运行时异常所以可以不用处理
//throw new RuntimeException("您输入的数据非法!");
//下面抛了一个既包括运行时异常又包括编译时异常的对象,所以抛完一定得处理
//不然会报错
//throw new Exception("您输入的数据非法");
throw new MyException("不能输入负数");
//错误的,只有异常类的对象才能被throw
//throw new String("不能输入负数");
}
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student [id=" + id + "]";
}
}
方法重写的规则之一:子类重写的方法抛出的异常类型
不大于父类
被重写的方法抛出的异常