自定义异常与编译时运行时异常

来源：互联网发布：yum 安装pip 编辑：程序博客网时间：2024/06/11 14:03

学到异常处理了，于是想记录下Java异常处理的细节，以增加对异常处理的印象。

Java常见的异常类之间的继承关系：

(仿李刚老师的《疯狂Java讲义》异常章节的图)

Java的异常被分为两大类:Checked异常(编译时出现异常)和Runtime(运行时异常)。

1、编译时被检测的异常，除了特殊子类RuntimeException体系的，只要是Exception和其子类都是。
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
2、编译时不检测异常(运行时异常)，就是Exception中的RuntimeException和其子类，这种问题的发生，让功能无法继续，运算也无法进行，更多是因为调用的原因导致的。或者引发程序内部状态改变，导致异常。这种问题一般不处理，直接编译通过，在运行时，调用者调用时引发异常从而程序强制停止，此时调用者即可对异常进行修正。

异常Demo演示：

[java] view plain copy
 
public class First  
{  
    private int num;  
      
    public void change(String str)  
    {  
        int a = Integer.parseInt(str);  
        this.num = a;  
    }  
      
    public static void main(String[] args)  
    {  
        First f = new First();  
        f.change("one");  
    }  
}  
/* 
编译这段代码后，运行出现NumberFormatException异常,这是一个运行时异常 
*/  

增加一个自定义的异常处理类：

[java] view plain copy
 
class MyException extends Exception    //自定义一个异常类，  
{  
    /*如果将MyException继承自RuntimeException，就没有后面的故事了，呵呵！ 
     *这样后，MyException就是一个运行时异常，从下面的叙述中， 
     *你应该能看出运行时异常和编译时异常的区别吧 
    */  
        public MyException(){}  
        public MyException(String msg)  
        {  
            super(msg);  
        }  
}  
public class First  
{  
    private int num;  
      
    public void change(String str)  
    {  
        try   
        {  
            int a = Integer.parseInt(str);  
            this.num = a;  
        }  
        catch(Exception e)  
        {  
            throw new MyException("You should pass a integer string.");  //抛出自定义异常  
        }  
  
    }  
      
    public static void main(String[] args)  
    {  
        First f = new First();  
        f.change("one");  
    }  
}  
/* 
编译这段代码后，出现错误： 
First.java:22: error: unreported exception MyException; must be caught or declared to be thrown 
                        throw new MyException("You should pass a integer string.");  //?????????? 
?? 
                        ^ 
1 error 
*/  

"未报告的异常，必须被捕获或者声明"，此处编译不能通过，对于自定义的异常类属于编译时异常，需要在函数在函数出进行声明，代码改成如下：

[java] view plain copy
 
class MyException extends Exception    //自定义一个异常类  
{  
    public MyException(){}  
    public MyException(String msg)  
    {  
        super(msg);  
    }  
}  
public class First  
{  
    private int num;  
      
    public void change(String str) throws MyException     //在方法声明上抛出，是为了告诉调用者，你注意了，我有问题  
    {  
        try   
        {  
            int a = Integer.parseInt(str);  
            this.num = a;  
        }  
        catch(Exception e)     
        {  
            throw new MyException("You should pass a integer string.");  //抛出自定义异常  
        }  
  
    }  
      
    public static void main(String[] args)  
    {  
        First f = new First();  
        f.change("one");  
    }  
}  
/* 
编译这段代码后，出现错误： 
First.java:30: error: unreported exception MyException; must be caught or declared to be thrown 
                f.change("one"); 
                        ^ 
1 error 
 
*/  

为什么还是不能编译通过呢？一开始在change()方法体内遇到throw new MyException("You should pass a integer string."); 准备抛出异常，可是change()方法没有显示声明这个异常，对于编译性的异常，需要显示进行声明，让JVM知道后续程序运行时该怎么处理。后来在change()方法声明了我的自定义异常:public void change(String str) throws MyException,所以change()方法中的MyException异常被抛到调用change()方法的main主函数中，所以出现了上面的错误，因而也需要在main主函数声明MyException。下面是正确代码：

[java] view plain copy
 
class MyException extends Exception    //自定义一个异常类  
{  
        public MyException(){}  
        public MyException(String msg)  
        {  
            super(msg);  
        }  
}  
public class First  
{  
    private int num;  
      
    public void change(String str) throws MyException  
    {  
        try   
        {  
            int a = Integer.parseInt(str);  
            this.num = a;  
        }  
        catch(Exception e)  
        {  
            throw new MyException("You should pass a integer string.");  //抛出自定义异常  
        }  
  
    }  
      
    public static void main(String[] args) throws MyException  //这里抛出自定义异常，但我们在程序开发时，通常不这么做  
    {  
        First f = new First();  
        f.change("one");  
    }  
}  
/** 
Exception in thread "main" MyException: You should pass a integer string. 
        at First.change(First.java:22) 
        at First.main(First.java:30) 
*/  

编译、运行上面的代码后，最终的MyException异常被抛给JVM，JVM打印出异常跟踪栈。对于这样的异常，可以进行必要的try catch操作。如：

[java] view plain copy
 
class MyException extends Exception    //自定义一个异常类  
{  
        public MyException(){}  
        public MyException(String msg)  
        {  
            super(msg);  
        }  
}  
public class First  
{  
    private int num;  
      
    public void change(String str) throws MyException // 注：如果MyException是一个RuntimeException, 这里就不用声明抛出了  
    {  
        try   
        {  
            int a = Integer.parseInt(str);  
            this.num = a;  
        }  
        catch(Exception e)  
        {  
            throw new MyException("You should pass a integer string.");  //抛出自定义异常  
        }  
  
    }  
      
    public static void main(String[] args)  
    {  
        First f = new First();  
        try  
        {  
                 f.change("one");  
        }  
        catch(MyException e)   //直接捕获并处理了  
        {  
            System.out.println("error: " + e.getMessage());  
        }  
    }  
}  

再对比一个编译时异常的例子：

[java] view plain copy
 
import java.io.IOException;  
import java.io.FileInputStream;  
public class Second  
{  
    public void fileTest()  
    {  
        FileInputStream fis = null;  
        try   
        {  
            fis = new FileInputStream("no-such-a-file.txt");  
        }  
        catch(Exception e)  
        {  
            throw new IOException();  
        }  
  
    }  
      
    public static void main(String[] args)  
    {  
        Second f = new Second();  
        f.fileTest();  
    }  
}  

也会出现：

Second.java:14: error: unreported exception IOException; must be caught or declared to be thrown
throw new IOException();
^
1 error
IOException是编译时异常，这样的错误, 所以你还是得在方法体上声明IOException，对于RuntimeException是不需要声明的。See next:

[java] view plain copy
 
import java.io.IOException;  
import java.io.FileInputStream;  
public class Second   
{  
    public void fileTest() throws IOException  
    {  
        FileInputStream fis = null;  
        try   
        {  
            fis = new FileInputStream("no-such-a-file.txt");  
        }  
        catch(Exception e)  
        {  
            throw new IOException();  
        }  
  
    }  
      
    public static void main(String[] args)  throws IOException  
    {  
        Second f = new Second();  
        f.fileTest();  
    }  
}  

这样就不会在编译时出现情况了，这算是应该注意的一个小细节吧。

下面再来看一个RuntimeException不需要声明的例子：

[java] view plain copy
 
class MyException3 extends RuntimeException {  
    private String message;  
  
    public MyException3() {  
    }  
  
    public MyException3(String mess) {  
        message = mess;  
    }  
  
    public String getMessage() {  
        return message;  
    }  
}  
  
public class NotDeclareRuntimeExceptionTest {  
      
    public static void runtimeExceptionTest1(int n) {   //这里不用声名抛出的异常 MyException3  
        if (n == 1) {  
            throw new MyException3();  
        } else {  
            System.out.println("dd");  
        }  
    }  
  
    public static void main(String[] args) {  
        System.out.println("ok");  
    }  
  
  
}  

参考博客：

http://www.blogjava.net/fancydeepin/archive/2015/10/15/382508.html

http://blog.csdn.net/hguisu/article/details/6155636

0 0