Java中的异常处理

异常

1.异常：程序出现的不正常情况。

2.错误：一般指硬件问题。这是非常严重的，我们一般处理不了。

3.异常分类：
非RuntimeException：即编译时期异常，程序运行之前。
RuntimeException：运行时期异常，程序运行起来以后。

4.针对异常，JVM默认的处理方案：
一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。并且，会自动从当前出问题的地方停止掉。
例如：这部分代码有一个除数为0的异常： java.lang.ArithmeticException: / by zero

package com.edu_01;

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("start");
        int a=10;
        int b=0;
        System.out.println(a/b);//java.lang.ArithmeticException: / by zero
        System.out.println("end");

    }

}

运行结果：

可以看到，程序执行到异常部分就停止了，end并没有输出。

5.处理异常而保证各个部分不受影响的两个方案：
（1）try…catch…finally

try{
    可能出现异常的代码
    }catch(异常类名 变量名) {
            针对异常的代码处理
    }finally {
    释放资源的地方
    }
 //我们简化一下：
try{
        可能出现异常的代码
    }catch(异常类名 变量名) {
        针对异常的代码处理
    }

finally：一般用于释放资源。
注意：finally中的语句体一定会被执行。
特殊情况：在执行到finally之前JVM退出了（例如System.exit（0））。

package com.edu_01;

public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("start");
        int a=10;
        int b=0;
        try{
            System.out.println(a/b);//当除数为0 的时候会抛出ArithmeticException这个异常
                                    //接着程序会拿着这个异常和catch里面的异常类进行对比
        }catch(ArithmeticException e){
            //当程序抛出ArithmeticException这个异常的时候给出具体的处理办法
            System.out.println("除数不能为0");
        }
        System.out.println("end");
    }

}

运行结果：

（2）throws
用在方法声明后面，跟的是异常类名；
可以跟多个异常类名，用,号隔开；
表示抛出异常，由该方法的调用者来处理；
throws表示出现异常的一种可能，并不一定会发生这些异常。

package com.edu_01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionDemo {
    public static void main(String[] args) {
        method();
        //method2();//将这个异常交给了调用者去进行处理:
                     //1.可以继续往上throws，将异常继续向上进行抛出了
                     //2.自己try..catch...,相当与自己处理了这个异常
        try{
            method2();
        }catch(FileNotFoundException e){
            System.out.println("文件找不到");
        }
    }

    private static void method2() throws FileNotFoundException{
        FileInputStream fis=new FileInputStream("D://a.txt");

    }

    private static void method() throws ArithmeticException{
        //在方法声明上声明这个方法可能出现的异常，不代表这个异常一定会出现
        //此时仅仅是告诉我的调用者我的这个方法可能会出现异常，并不做具体的处理，交给调用者自己去处理这个异常:
            //1.继续向上抛出
            //2.try…catch… 相当于自己处理了这个异常
        //此时抛出的除数为0的异常，属于运行时期异常
        System.out.println(10/0);

    }

}

运行结果：

当我们把除法的输出改为10/2时，即：System.out.println(10/2);
运行结果：

6.多个异常的处理：
（1）针对每一个出现问题的地方写一个try…catch…语句
（2）针对多个异常，采用一个try，多个catch的情况：try…catch…catch…
遇到try里面的问题，就自动和catch里面进行匹配，一旦匹配catch里面的内容，执行完毕后接着执行后面的内容。
注意：如果异常间有父子关系，父必须在最后，否则会报错。

package com.edu_01;

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        try{
            System.out.println(10/0);//抛出了ArithmeticException异常
            //System.out.println(arr[3]);//抛出了ArrayIndexOutOfBoundsException异常
            //arr = null;
            //System.out.println(arr[2]);//抛出了NullPointerException异常
        }catch(ArithmeticException e){//Exception e = new ArithmeticException();多态的一种
            System.out.println("除数不能为0");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("数组越界");
        }catch(Exception e){//当前面的异常类都没有匹配到，会自动匹配到这个异常上
            System.out.println("出现了其他异常");
        }
    }

}

运行结果：

当try里面的语句变为下面的代码时：

try{
            //System.out.println(10/0);//抛出了ArithmeticException异常
            System.out.println(arr[3]);//抛出了ArrayIndexOutOfBoundsException异常
            //arr = null;
            //System.out.println(arr[2]);//抛出了NullPointerException异常
        }

运行结果：

当try里面的语句变为下面的代码时：

try{
            //System.out.println(10/0);//抛出了ArithmeticException异常
            //System.out.println(arr[3]);//抛出了ArrayIndexOutOfBoundsException异常
            arr = null;
            System.out.println(arr[2]);//抛出了NullPointerException异常
        }

运行结果：

7.编译时期异常和运行时期异常的区别：
（1）编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译。
（2）运行时期异常：无需显示处理，也可以和编译时期异常一样处理。

8.throwable中的方法：
printStackTrace()：打印异常信息，程序从出问题的地方就会打印一个该异常对应的对象，该对象直接调用打印方法。

package com.edu_01;

public class ExceptionDemo {
    public static void main(String[] args) {
        try{
            System.out.println(10/0);//程序运行之后抛出了一个ArithmeticException的对象
            //new ArithmeticException()
        }catch(ArithmeticException e){//ArithmeticException e=new ArithmeticException();
            e.printStackTrace();//打印异常信息
            //java.lang.ArithmeticException: / by zero
            //at com.edu_01.ExceptionDemo6.main(ExceptionDemo6.java:12)
        }
    }
}

运行结果：

9.try…catch…和throws的区别：
（1）try…catch…是直接进行了处理；
（2）throws是把异常处理的问题交给了调用者。throws用在方法上，声明方法有异常，交给调用者处理：

编译时期异常：调用者就必须处理；
运行时期异常：调用者可以处理，也可以不处理。

10.final和finally的区别：
final：最终的意思。可以修饰类、方法、变量。

修饰类，类不能被继承。
修饰方法，方法不能被重写。
修饰变量，变量变成常量。

finally：异常处理的一部分。被finally控制的语句一定会被执行。
特殊情况：在执行到finally之前，JVM退出了。

11.父类和子类异常问题：
（1）子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。
（2）如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是它的子类,子类不能抛出父类没有的异常。
（3）如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws。
这些都是针对编译时期异常，与运行时期异常无关。

12.throw和throws的区别：
（1） throws:
* 用在方法声明后面，跟的是异常类名；
* 可以跟多个异常类名，用逗号隔开；
* 表示抛出异常，由该方法的调用者来处理；
* throws表示出现异常的一种可能性，并不一定会发生这些异常。
*
（2） throw:
* 用在方法体内，跟的是异常对象名；
* 只能抛出一个异常对象名；
* 表示抛出异常，由方法体内的语句处理；
* throw则是抛出了异常，执行throw则一定抛出了某种异常。

package com.edu_03;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowDemo {
    public static void main(String[] args) {
        method();
        try{
            method2();
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
    }

    private static void method2() throws FileNotFoundException{
        try{
            FileInputStream fis = new FileInputStream("D//a.txt");
        }catch(FileNotFoundException e){
            //当碰到这个异常后，直接抛出（这是我的处理方法）
            //编译时期异常，必须在方法声明上声明
            throw new FileNotFoundException();
        }

    }

    private static void method() throws ArithmeticException{
        int a=10;
        int b=0;
        if(b==0){
            //运行时期异常，抛出这个异常的同时可以在方法声明上声明，也可以不声明
            throw new ArithmeticException();
        }else{
            System.out.println(a/b);
        }

    }

}

运行结果：