编译时异常和运行时异常的小细节

清疚 2022-08-02 15:46 278阅读 0赞

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

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

![Center][]![Image 1][]![Image 1][]

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

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

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

异常Demo演示：

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异常,这是一个运行时异常
    */

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

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
    */

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

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。下面是正确代码：

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操作。如：

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());
    		}
    	}
    }

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

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:

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不需要声明的例子：

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_www.blogjava.net_fancydeepin_archive_2015_10_15_382508.html]

[http://blog.csdn.net/hguisu/article/details/6155636][http_blog.csdn.net_hguisu_article_details_6155636]

[Center]: https://img-blog.csdn.net/20150726131227688?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Image 1]: 
[http_www.blogjava.net_fancydeepin_archive_2015_10_15_382508.html]: http://www.blogjava.net/fancydeepin/archive/2015/10/15/382508.html
[http_blog.csdn.net_hguisu_article_details_6155636]: http://blog.csdn.net/hguisu/article/details/6155636