异常专题总结

生活中和程序中都有异常，它们有很多的共同点，唯一一个特别相似的就是给人们带来很多的烦恼，但是异常是不可避免的，下面来举例一下。比如：平时8点10分上课，老师都会7.50之前到达教师，有一次，老师迟到了，8.20才到的教室，这就是出现了异常。

而程序中也有许许多多的异常，没有一个程序说是完美的，一点隐藏的异常都没有。

异常的父类、超类：Throwable（可抛出的，一切错误或异常的父类位于java.lang包中）

概念：程序在运行过程中出现的特殊情况

异常处理的必须性：任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失

Throwable子类：Error和Exception

 

Error：
JVM、硬件、执行逻辑错误，不能手动处理

 

Exception：
程序在运行和配置中产生的问题，可处理

Exception子类：RuntimeException(运行时异常，可处理，可不处理)、CheckedException(受查异常，必须处理)

异常的产生：

1.自动抛出异常：当程序在运行时遇到不合规范的代码结果时，会产生异常

2.手动抛出异常：语法：throw new 异常类型（"实际参数"）；

3.产生结果异常：相当于遇到return语句，导致程序因异常而终止

异常的传递：

1.异常的传递：按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）

2.受查异常：throws声明异常，修饰在方法参数列表后端

3.运行时异常：因可处理可不处理，无需声明异常

异常的处理：

throws Exception 位于参数后，表示提供异常，一旦提供，不在此处解决异常，向上报告，在调用除解决异常或JVM打印堆栈跟踪信息

常见异常处理结构：

try{}  catch(){}

try{} catch(){}  catch(){}     （父类要在子类的下面，子类顺序无所谓，Exception的同级别的throwable的子类（满足需求才能太添加的）位置在父类前面即可）

try{} catch(){}  finally{}

try{} catch(){}  catch(){}  finally{}

try{} finally{}

多重catch，遵循从子（小）到父（大）的顺序，父类异常在最后。

finally:

无论出不出现异常都会执行finally中的逻辑代码。

 

//核心方法（每个用户都需要使用）5万
try{
    //使用资源对象-->发生了异常
    //发生了异常
}catch（Exception e）{
       e.printStackTrace();
}finally{
    //使用完毕，关闭资源
}

 

 

自定义异常：

场景：根据自身的需求去创建异常

要求：需要继承Exception 或 RuntimeException,常用于RuntimeException

public class TestTimeException {
    public static void main(String[] args) {
        Student stu = new Student();
        try {
            stu.setTime(50);
        } catch (TimeException e) {
            System.err.println("程序错误原因：" + e.getMessage());
        }
    }
}
class Student{
    private int time;
    public int getTime() {
        return time;
    }
    public void setTime(int time) throws TimeException {
        if(time > 36){
            throw new TimeException("假期时间过长异常");
        }
        else{
            this.time = time;
        }
    }
}
class TimeException extends Exception{
    public TimeException(String maessage){
        super(maessage);
    }    
}

输出结果：程序错误原因：假期时间过长异常

方法覆盖：

方法名、参数列表、返回值必须和父类相同

子类的访问修饰符符合父类相同或是比父类更宽

子类中的方法，不能抛出比父类更宽泛的异常

下面是可能出现的场景：

//带有异常的方法覆盖
//1.父类中方法声明了异常。子类重写后可声明也可不声明
class Super{
    public void m()throws Exception{}
}
class Sub extends Super{
    public void m(){}
}

 

//2.父类中方法没有声明异常，则子类也不可以声明异常。
class Super{
    public void m(){}
}
class Sub extends Super{
    public void m(){}
}

 

//3.父类中方法声明了异常，子类可以声明的异常与其相等或是其子类
class Super{
    public void m()throws Exception{}
}
class Sub extends Super{
    public void m()throws Exception{}
}
//--------------------------------------------------------------------
class Super{
    public void m()throws Exception{}
}
class Sub extends Super{
    public void m()throws RuntimeException{}
}

//4.子类可以声明比父类更多的异常。必须小于其父类声明的异常
class Super{
    public void m()throws Exception{}
}
class Sub extends Super{
    public void m()throws RuntimeException , InterruptedException ,MimeTypeParseException , IOException{}
}
接口与相似