JavaEE-19-Java异常处理

一.异常定义：

在Java中用类的形式对不正常情况进行了描述和封装对象，其中，描述不正常情况的类，就称为异常类。

以前，正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离，提高阅读性。

其实，异常就是Java通过面向对象的思想将问题封装成了对象。用异常类对其进行描述。

不同的问题用不同的类进行具体的描述。(比如角标越界、空指针等等)

问题很多，意味着描述的类也很多，将其共性进行向上提取，形成了异常体系。

最终问题(不正常情况)就分成了两大类：

　　1.一般不可处理的。(Error)

　　2.可以处理的。(Exception)

 

二.异常的体系：

　　Throwable：无论是Error，还是Exception，都是问题，问题发生就应该抛出，让调用者知道并处理。

　　该体系的特点就在于Throwable及其所有的子类都具有可抛性。

　　　　Error:(不可处理的)

　　　　　　通常出现重大问题如：运行的类不存在或者内存溢出等。(注意，是运行时的异常，而编译时是没有错误提示的)

　　　　　　特点：是由jvm抛出的严重性的问题，这种问题发生一般不针对性处理，直接修改程序。

　　　　Exception:(可处理的)

　　　　　　在运行时运行出现的一起情况，可以通过try catch finaly。

Exception和Error的子类名都是以父类名作为后缀。

该体系的特点就在于Throwable及其所有的子类都具有可抛性。

 

三.异常的分类：

　　1.编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。

　　　　这种问题一旦出现，Java程序必须显式处理，否则程序就会发生错误，无法通过编译。

　　　　(这样的问题都可以针对性处理)

　　2.编译时不检测异常(运行时异常)：就是Exception中的RuntimeException和其子类。

　　　　这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的或者引发了内部状态的改变导致的。

　　　　(这种问题无需显式处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。)

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

注：RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

 

四.异常处理的两种方式：

　　选择原则：如果该功能内部可以将问题处理，则用try...catch;(后续程序需要继续运行)---一般会使用这种方式

　　　　　　　如果内部处理不了，则交由调用者来处理，使用throw抛出异常。(后续程序不需要继续运行)

1. throw 抛出异常

　　throws和throw的区别：

　　1.throws使用在方法声明后面；

　　　throw使用在方法体内。

　　2.throws抛出的是异常类，可以抛出多个，用逗号隔开;

　　　throw抛出的是对象，一次只能抛出一个。

　　3.throws表示抛出异常，由该方法的调用者来处理；

　　　throw表示抛出异常，由方法体内的语句处理；

　　4.throws表示出现异常的一种可能性，并不一定会发生这些异常

　　　而throw则表示一定抛出了某种异常。

 

2. try...catch...finally

　　异常处理的捕捉形式：这是可以对异常进行针对性处理的方式，前面的异常不处理，后面的代码将不会继续运行。

　　原则：

　　　　1.try里面的代码越少越好(try中的代码需要走异常处理机制，即java虚拟机需要开辟新的资源来管理它)

　　　　2.catch中的代码必须有内容，哪怕是给个简单的提示，也能让人知道异常的原因是什么，不然就是隐藏异常了。

　　具体格式：

　　　　try ｛

　　　　　　//可能出现异常的代码

　　　　　　}

　　　　catch(异常类 变量) ｛

　　　　　　//处理异常的代码

　　　　　　}

　　　　finnaly｛

　　　　　　//一般会被执行的代码

　　　　　　}

 举例：

public class ExceptionDemo {
    public static void main(String[] args) {
        method();
    }
    private static void method() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println("除数不能为0");
        }

        int arr[] = { 1, 2, 3 };
        try {
            System.out.println(arr[3]);
        } catch (Exception e) {
            System.out.println("越界");
        }
        System.out.println("over");
    }
}

上面这段代码有个问题，但代码中有多个异常时，多次使用try语句，这样既繁琐，代码也不美观。

此时，我们可以对代码进行改进，将有异常的代码放到同一个try代码块中，具体如下：

注意：两个catch的参数的类型不能相同。

public class ExceptionDemo {
    public static void main(String[] args) {
        method();
    }
    private static void method() {
        int a = 10;
        int b = 0;
        int arr[] = { 1, 2, 3 };
        try {
            System.out.println(a / b);
            System.out.println(arr[3]);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("越界");
        }
        System.out.println("over");
    }
}

 上面的代码中，一个try对应多个catch的方式相对于第一个代码，是变得简洁了些。

但JDK7之后，出现了一个更简洁的方式：catch中使用多个异常名，这样一来，catch也只要一个就够了。

注意：这种方式有两个弊端

　　　　1.catch语句是同一条，即处理方式是一样的；

　　　　2.异常名不能使用exception；

　　格式：

　　try{

　　　　......

　　}catch(异常名1 | 异常名2 | ...... 变量) {

　　　　......

　　} 

 

异常处理的原则：

　　1.函数内容如果抛出需要检测的异常，那么函数上必须要声明。

　　　否则必须在函数内用trycatch捕捉，否则编译失败。

　　2.如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。

　　3.什么时候catch，什么时候throws呢？

　　　功能内容可以解决，用catch；

　　　解决不了，用throws告诉调用者，由调用者解决。

　　4.一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。

　　　内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

 

try catch finally组合特点：

　　1.try catch finally

　　2.try catch(多个)  当没有必要资源需要释放时，可以不用定义finally。

　　3.try finally 异常无法直接catch处理，但要资源需要关闭。

 

举例：　　

　　毕老师用电脑讲课：
　　　　对象：毕老师，电脑
　　　　方法：讲课，运行

　　　　异常1：电脑蓝屏，异常2：电脑冒烟

　　代码：

class LanPingException extends Exception//异常1
{
    LanPingException(String msg)
    {
        super(msg);
    }
}
class MaoYanException extends Exception//异常2
{
    MaoYanException(String msg)
    {
        super(msg);
    }
}
class NoPlanException extends Exception//异常转换
{
    NoPlanException(String msg)
    {
        super(msg);
    }
}

class Computer//对象1
{
    private int state = 2;//设定电脑开机后的3种状态
    public void run() throws LanPingException,MaoYanException
    {
        if(state==1)
            throw new LanPingException("电脑蓝屏啦！");
        if(state==2)
            throw new MaoYanException("电脑冒烟啦！");
        System.out.println("电脑运行");
    }
    public void reset()
    {
        state = 0;
        System.out.println("电脑重启");
    }
}

class Teacher//对象2
{
    private String name;
    private Computer comp;
    Teacher(String name)
    {
        this.name = name;
        comp = new Computer();
    }

    public void prelect() throws NoPlanException
    {
        try
        {
            comp.run();
            System.out.println(name+"讲课");
        }
        catch(LanPingException e)
        {
            System.out.println(e.toString());//显示错误异常信息
            comp.reset();
            prelect();
        }
        catch(MaoYanException e)
        {
            System.out.println(e.toString());
            test();
            throw new NoPlanException("课时进度无法完成，原因："+e.getMessage());
        }
        
    }
    public void test()
    {
        System.out.println("大家练习");
    }
}

class ExceptionTest 
{
    public static void main(String[] args) 
    {
        Teacher t = new Teacher("毕老师");
        try
        {
            t.prelect();
        }
        catch (NoPlanException e)
        {
            System.out.println(e.toString()+"...");
            System.out.println("换人");
        }
        
    }
}

 

异常的注意事项：

　　1.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

　　2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

　　用一句话概括上面的话就是：子类覆盖父类只能抛出父类的异常或者子类或者子集。

　　注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛。