异常

 

1. 什么是异常

2. 在java中将可能导致程序执行意外失败的时间叫做异常，异常会终端程序的运行（世界上没有不会出错的程序）

    

   java中异常的处理

   程序中预先想好了对付异常的处理办法——程序运行——出现异常——对异常进行处理——处理完毕，程序继续运行

    

3. java中的异常处理

4. java中的异常处理是通过5个关键字来实现的：

   Try    catch    finally    throw    throws

    

   try：执行可能产生异常的代码

   catch：捕获异常，然后处理

   finally：无论是否发生异常，代码总能执行

   throw：手动抛出异常

   throws：声明方法中可能要出现的各种异常 

    

5. 异常的分类    

6. 异常主要分为：错误、运行时异常、非运行时异常（收检查异常）

    

   错误：如果应用程序出现了Error，那么将无法回复，只能重新驱动应用程                          序，最典型的Error异常是：OutOfMemoryError

   非运行时异常：出现了这种异常必须显示的处理，不显示处理java程序将无法编译通过

   运行时异常：此种异常可以不用显示的处理，例如被0除异常，java没有要求我们必须要处理，当出现这种情况时，肯定是程序员的问题

    

7. java异常处理机制

8. 1.java程序的执行过程中如果出现异常，会自动生成一个异常类对象，该异常对象将被提交给java运行时系统，这个过程叫抛出异常

   2.当java运行时系统接受到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程叫做捕获异常

   3.如果java运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的java程序也将退出

   4.程序员通常只能处理Exception，对Error无能为力

    

9. 处理异常关键字的使用

10. 异常的捕获和处理需要采用try和catch来处理，具体格式如下：

    try {

    }catch(OneException e) {

     

    }catch(TwoException e) {

     

    }finally {

    }

    1.try中包含了可能产生异常的代码

    2.try后面是catch，catch可以有一个或多个，catch中是需要捕获的异常

    3.当try中的代码出现异常时，出现异常下面的代码不会执行，马上会跳转到相应的catch语句块中，如果没有异常不会跳转到catch中

    4.finally表示，不管是出现异常，还是没有出现异常，finally里的代码都执行，finally和catch可以分开使用，但finally必须和try一块使用，如下格式使用finally也是正确的

       例：Try {}

                finally{}

     

    取得异常对象的具体信息：

    getMessage()可以取得异常描述信息

    printStackTrace()可以取得异常的堆栈信息

     

    异常的声明

    //声明受控异常

    import java.io.*;

     

    public class ExceptionTest13 {

     

    public static void main(String[] args)        

    //throws FileNotFoundException, IOException { //可以在此声明异常，这样就交给java虚拟机处理了，不建议这样使用

    throws Exception { //可以采用此种方式声明异常，因为Exception是两个异常的父类

            

    //可以采用如下方式处理异常

    //因为Exception是FileNotFoundException和IOException的父类

    //但是一般不建议采用如下方案处理异常，粒度太粗了，异常信息

    //不明确

     

    readFile();

    }

     

    private static void readFile()

    throws FileNotFoundException,IOException { //声明异常，声明后调用者必须处理

    FileInputStream fis = null;

    try {

    fis = new FileInputStream("test.txt");

    //}catch(FileNotFoundException e) {

    //        e.printStackTrace();

    }finally {

    //try {

    fis.close();

    //}catch(IOException e) {

    //        e.printStackTrace();

    //}        

    }

    }

    }

     

    //声明非受控异常

    public class ExceptionTest14 {

     

    public static void main(String[] args)        {

    //不需要使用try...catch..，因为声明的是非受控异常

    //method1();

     

    //也可以拦截非受控异常

    try {

    method1();

    }catch(ArithmeticException e) {

    e.printStackTrace();                

    }

    }

     

    //可以声明非受控异常

    private static void method1() throws ArithmeticException {

    int i1 = 100;

    int i2 = 0;

    // try {

    int i3 = i1/i2;

    System.out.println(i3);        

            

    }

    }

     

    //手动抛出异常

    public class ExceptionTest16 {

     

    public static void main(String[] args)        {

    //int ret = method1(10, 2);

    //System.out.println(ret);

     

     

    try {

    int ret = method1(1000, 10);

    System.out.println(ret);

    }catch(Exception iae) { //可以采用Exception拦截所有的异常

    System.out.println(iae.getMessage());

    }

     

    }

     

    private static int method1(int value1, int value2){

    if (value2 == 0) {

    手动抛出异常

    throw new IllegalArgumentException("除数为0");

    }

    if (!(value1 >0 && value1<=100)) {

    //手动抛出异常

    throw new IllegalArgumentException("被除数必须为1~100之间的数据");

    }

    int value3 = value1/value2;

    return value3;

    }

    }

     

    //异常的捕获顺序

    异常的捕获顺序应该是：从小到大

    import java.io.*;

     

    public class ExceptionTest18 {

     

    public static void main(String[] args)        {

    try {

    FileInputStream fis = new FileInputStream("test.txt");

    fis.close();

    }catch(IOException e) {

    e.printStackTrace();

    }catch(FileNotFoundException e) {

    e.printStackTrace();

    }        

    //将IOException放到前面，会出现编译问题

    //因为IOException是FileNotFoundException的父类，

    //所以截获了IOException异常后，IOException的子异常

    //都不会执行到，所以再次截获FileNotFoundException没有任何意义

    //异常的截获一般按照由小到大的顺序，也就是先截获子异常，再截获父异常

    }

    }

     

    //自定义异常

    import java.io.*;

     

    public class ExceptionTest20 {

     

    public static void main(String[] args)        {

    method1(10, 0);

    }

     

     

    private static void method1(int value1, int value2)

    //throws MyException {

    if (value2 == 0) {

    //抛出非受控异常，方法可以不适用throws进行声明

    //但也也可以显示的声明

    throw new MyException("除数为0");        

    }

    int value3 = value1 / value2;

    System.out.println(value3);

    }

    }

     

    //自定义非受控异常

    class MyException extends RuntimeException {

     

    public MyException() {

    //调用父类的默认构造函数

    super();

    }

     

    public MyException(String message) {

    //手动调用父类的构造方法

    super(message);        

    }

    }

     

     

11. 方法覆盖中的异常

12. 当子类中的方法覆盖父类中的方法时，可以抛出异常

    1，如果父类的方法没有声明抛出异常，那么子类覆盖方法可以抛出运行时异常，系统只能在运行时才能判断是否出错的异常

    2.如果父类的方法声明抛出异常（包括自定义的异常），那么子类覆盖方法可以不声明抛出异常，如果子类覆盖方法要抛异常的话，只能抛出与覆盖方法的相同的异常或者被覆盖方法的异常子类的异常

     

13. 总结

14. 1.异常是运行时发生的错误

    2.可以使用try、catch、finally、throw、throws来管理java异常处理。要监控的程序包含在try块内catch块中的代码用于捕获和处理异常。在方法返回之前绝对必须执行的代码应放置在finally块中

    3.要手动引发异常，使用关键字throw。任何被跑到方法外部的异常都必须用throws指定

    4.多重catch和嵌套try-catch可以使用

    5.自定义异常可以继承Exception和RuntimeException