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

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

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

    

      (仿李刚老师的《疯狂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://blog.csdn.net/hguisu/article/details/6155636