javase学习第11天（异常）

 

异常

 

异常指的是在运行期出现的错误；在编译阶段出现的语法错误等，不能称之为异常。

Error:

虚拟机无法解决的严重问题，如jvm系统内部错误，系统崩溃，动态链接失败等等，这种错误无法恢复或不可能捕获，将导致应用程序中断，通常程序无法处理这些错误，也不能试图通过catch块来捕获，一般不进行处理。

Exception：

其他因程序设计错误或偶然外在因素导致的一般性问题，可以使用针对性的代码进行处理，如算法异常、空指针访问、数组下标越界、所读文件不存在等。主要分两类：

1、编译异常，必须处理后才能正常编译；java程序必须捕获或声明所有编译时异常；

2、运行时异常RuntimeException，这种异常可以处理，也可以不处理。解决办法：

1、遇到错误就终止程序的运行，即不对异常进行处理；

2、在程序编写时，就考虑错误的检测、错误消息的提示，在抛给java运行时环境的时候，将这个异常对象捕获，再进行处理。

class TestError{
    public static void main(String[] args){
        byte[] arr = {1,2,3};
        try{
            System.out.println(arr[3]);//加上try块
        }catch(Exception e){
            System.out.println("发生数组索引越界异常");
        }
    }
}

 

try尝试：将可能发生异常的语句放入其中； catch捕获：当try块中的异常发生时，拿该异常区匹配catch块中的异常类，如果匹配，就执行这个catch块中 的语句，可以有多个catch块。当然只能有一个catch块被执行。 注意：catch语句块排放顺序，一定要先捕获小异常（子），再捕获大异常（父).

访问异常信息

 

所有异常对象包含以下常用方法：

1、getMessage():返回该异常的详细描述信息；

2、printStackTrace():将异常的跟踪栈信息打印出来；

3、printStackTrace(PrintStream s):将异常的跟踪栈信息输出到指定的输出流；

4、getStackTrace():返回该异常的跟踪栈信息。

 

几种常见异常：

类型转换异常（ClassCastException)、空指针异常（NullPointerException)；

编译时异常（必须捕获）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ErrorDemo {
    public static void main(String[] args) {
        FileInputStream in = null;
        // in = new FileInputStream("a.txt");//error，没有捕获
        try{
            in = new FileInputStream("a.txt");//有可能会抛出异常，必须捕获
        }catch(FileNotFoundException fe){
            fe.printStackTrace();
        }
    }
}

 

finally回收资源

 

在try语句中打开的物理资源，比如数据库连接、网络连接、磁盘文件等，都必须显示回收。 Java中的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收内存中对象所占用的内存资源。可使用finally进行。

除非在try块，catch块中调用了退出虚拟机的方法（System.exit(-1))，否则不管在try块，catch块中执行怎样的代码，出现怎样的情况，finally块中的语句中会被执行。 通常情况下，不要在finally块中使用return或者thorw等导致方法终止的语句，一旦在finally块中使用了return或者throw语句，将会导致try块，catch块中的return，throw语句失效。

class FinallyTest1{
    public static void main(String[] args){
        int res = test();
        System.out.println(res);
    }
    public static int test(){
        try{
            int x = 2/0;
            System.out.println("a");
            return 1;
        }
        catch(Exception e){
             return 2;
         }
        finally{
            return 3;
        }
    }
}

 

当程序在try/catch中遇到了return或者是throw语句，程序停止执行，但是并不会立即结束该方法，而是去寻找是否包含了finally块，如果没有finally块，则立即执行return或者throw语句，方法终止；如果有finally块，程序立即开始执行finally块，只有当finally块中语句执行完了，系统才会返回到try块中执行return或者是throw语句；如果finally块中也包含了return或者是throw等导致方法结束的语句，则在finally块中已经终止了方法，程序就不会再跳回去执行try块，catch块中的任何代码。换句话说，在finally中的return语句提前终止了方法。

 

Checked 异常和Runtime异常体现

Checked异常：编译时异常

Runtime异常：运行时异常

使用throws声明抛出异常

 

使用throws抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常应该由上一级的调用者处理；如果main方法也不知道如何处理这种类型的异常，也可以使用throws继续声明抛出异常，该异常将交给JVM处理。JVM对异常的处理方法是，打印异常的跟踪栈信息，并终止程序运行。

throws声明抛出异常只能在方法签名中使用，throws可以声明抛出多个异常类，彼此之间用逗号隔开；

一旦一个方法使用throws声明抛出异常，程序就无法使用try，catch块来捕获该异常了。

import java.io.*;
class ThrowsDemo2{
    public static void main(String[] args) throws Exception{
        //此处也可以使用try，catch块来捕获异常并做处理，或者再次抛出
        test();
    }
    public static void test() throws Exception{
        FileInputStream fis = new FileInputStream("a.txt");
    }
}

 

注意：方法重写时，子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或者相同，子类声明抛出的异常不允许比父类方法声明抛出的异常大。

两种异常的区别

 

1、如果throw语句抛出的异常是Checked异常，则该throw语句要么处于try块里，显式捕获该异常，要么放在一个带throws声明抛出的方法中，即把该异常交给方法的调用者处理；

2、如果throw语句抛出的是Runtime异常，则该语句无须放在try块中，也无须放在带throws声明的方法：这种运行时异常可以捕获，也可以完全不理会。

import java.io.IOException;
class ThrowsDemo{
    public static void main(String[] args) {
//被调用的checkedEx方法会抛出异常，并且是编译异常，必须用try，catch捕获，或者是在调用的方法上继续声明抛出
        try{
            checkedEx();
        }catch(Exception e){
            e.printStackTrace();
        }
//被调用的方法会抛出运行时异常，可以完全不理会，由调用者处理，这里的调用者就是main方法
        runtimeEx();
    }
    //调用此方法肯定会抛出IOException
    public static void checkedEx() throws IOException{
        //方法中抛出的异常是编译异常，必须要进行处理：要么放在try块中，要么在方法声明上加上抛出声明
        throw new IOException("checked Exception");
    }
    //调用此方法肯定会抛出异常，运行时异常，可以不处理
    public static void runtimeEx(){
        //方法中抛出的异常是运行时异常，可以处理，也可以不理会
        throw new NullPointerException("runtime Exception");
    }
}

 

自定义异常

 

定义异常类时通常需要提供两个构造方法，一个是无参的，一个是带有一个字符串的构造方法，这个字符串将作为该异常对象的描述信息，也就是异常对象的getMessage方法的返回值。

public class MyException extends Exception{
    //无参构造方法
    public MyException(){}
    //带一个字符串的构造方法，用来传递异常信息
    public MyException(String msg){
        super(msg);
    }
}

/**
编写应用程序EcmDef.java，接收命令行的两个参数，要求不能输入负数，计算两数相除。
对数据类型不一致(NumberFormatException)
缺少命令行参数(ArrayIndexOutOfBoundsException
除0(ArithmeticException)
及输入负数(EcDef 自定义的异常)进行异常处理。
*/

class EcDef{
    public static void main(String[] args){
        try{
            int a=Integer.parseInt(args[0]);
            int b=Integer.parseInt(args[1]);
            // int res = div(a,b);
            int res = div(a,b);
            System.out.println(res);
            
        }catch(NumberFormatException e){
            System.out.println("输入格式错误");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("输入个数异常");
        }catch(ArithmeticException e){
            System.out.println("除数不能为0异常");
        }catch(EcDefExce e){
            System.out.println(e.getMessage());
        }
        
        
    }
    public static int div(int a,int b) throws EcDefExce{//自定义异常未明显说明是runtime异常，所以必须抛出
        if(a<0||b<0){
            throw new EcDefExce("输入不能为负数");
        }
        
        return a/b;
    }
}
//自定义异常
class EcDefExce extends Exception{
    public EcDefExce(){}
    public EcDefExce(String msg){
        super(msg);
    }
}

 

子类重写父类方法时异常处理

 

注意四点：

1、可以和父类方法抛出一样异常

2、抛出的异常可以是父类异常的子类，不能是父类方法抛出异常的父类

3、抛出的异常可以比父类多

4、可以不抛出任何异常

 

异常处理图例

异常处理总结：

java 提供了两种方式用来处理一个异常类的对象。

处理的方式一：

try{
        //可能出现异常的代码
     }catch(Exception1 e1){
         //处理的方式1
     }catch(Exception2 e2){
         //处理的方式2
     }finally{
         //一定要执行的代码 
     }

 

注：

1.try内声明的变数，类似于局部变量，出了try{}语句，就不能被调用

2.finally是可选的。

3.catch语句内部是对异常对象的处理： 常用的是：e.printStackTrace();

4.可以有多个catch语句，try中抛出的异常类对象从上往下去匹配catch中的异常类的类型，一旦满足就执行catch中的代码。执行完，就跳出其后的多条catch语句

5.如果异常处理了，那么其后的代码继续执行。

6.若catch中多个异常类型是"并列"关系，孰上孰下都可以。 若catch中多个异常类型是"包含"关系，须将子类放在父类的上面，进行处理。否则报错！

7.finally中存放的是一定会被执行的代码，不管try中、catch中是否仍有异常未被处理，以及是否有return语句。

8.try-catch是可以嵌套的。

 

处理的方式二：在声明中进行throws抛出

 

1、对于运行时异常来说，可以不显式的进行处理。

2、对于编译时异常来说，必须要显式的进行处理。