exception runtimeexception我对这两个有点蒙了，求高人解答，能用形象例子更好，说说两者的区别，什么时候用哪个合适

Exception 就是根异常，是所有异常的基类。写代码的try{}catch{}语句的时候，如果有多个exception直接抛出一个exception就能将所有的exception抛出了，你也可以将所有的不同exception依依抛出。

RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明，一般是由于你程序设计的有漏洞`比如 1/0~的情况， 正确设计不会出现的` 一般不捕获或处理。

Exception可以分为两种：一种为已检查异常，就像楼上说，出现这种异常一定是你程序的问题。还有一种是未检测异常：这种异常需要throws 或try catch，这种异常往往是调用底层资源是出错

Exception是所有异常的父类，只要你在catch里面捕捉了这个异常，那么所有异常都会给你捕捉到，不管是运行异常还是编译异常。
RuntimeException是指运行异常，是Exception的一个子类，就是这个语句明明是有错误的，但是在语法上没有错误，编译的时候可以通过，但是运行的时候却会出现错误。
例如数组角标越界，int[] arr = new arr[10];System.out.print(arr[11]);这样子在语法上是没有错误的，但是在数组只有10的长度，你却让它输出11的长度，所以会在运行时出现角标越界错误

这是代码，你多看几遍毕老师的视频，讲的很详细了，我的代码全是他视频里的。加油，我也是刚弄回。看到我哪里错了也帮我说出来，谢。

1. 
   
2. //Exception：是所有异常的子类，在实例中一般都是抛出具体异常，多个异常存在时，函数上要全部声明，逗号隔开
   
3. //                         在函数内部，用相同个数的catch块捕获对应的异常；
   
4. public class ExceptionDemo1 {
   
5.         public static void main(String[] args) {
   
6.                 Div1 d = new Div1();
   
7.                 try {
   
8.                         int x = d.method(4, -1);                                //方法二：异常的代码在函数内部进行try catch处理
   
9.                         System.out.println("x= " + x);
   
10.                 }catch(FuShuException e) {                                        //catch中捕获抛出的负数异常
    
11.                         System.out.println(e.toString());
    
12.                 }
    
13.                 System.out.println("over");
    
14.         }
    
15. }
    
16. 
    
17. class Div1 {
    
18.         int method(int a, int b) throws FuShuException{        //方法一：在函数上声明（throws）让调用者(main函数)处理
    
19.                 if(b < 0)
    
20.                         throw new FuShuException("出现了负数———by fushu");        //通过throw关键字抛出自定义异常，并处理该异常；
    
21.                 return a/b;                                                                                //有两种处理方式：方法一，方法二
    
22.         }                                                                                                //一般情况下，函数内出现异常，函数上要声明；
    
23. }
    
24. 
    
25. class FuShuException extends Exception {//继承Exception类                       
    
26.         FuShuException(String message) {        //父类中对于获取异常信息的功能已经完成，子类构造器通过super()语句；
    
27.                 super(message);                                        //把异常信息传递给父类即可
    
28.         }
    
29. }       
    
30. /*
    
31. //RuntimeException：是Exception的子类，该类及其子类对象发生后，方法内throw该类或子类对象，
    
32. //                                        方法上不用声明（throws），也不用try catch处理
    
33. public class ExceptionDemo1 {
    
34.         public static void main(String[] args) {       
    
35.                 Div1 d = new Div1();
    
36.                         int x = d.method(4, -1);                //这里发生负数异常，下面代码不会执行，同时主函数也不用声明（throws）异常，
    
37.                         System.out.println("x= " + x);        //主函数内部也不用try catch语句处理，异常交由jvm处理，这时需要修正异常代码-1
    
38.                 System.out.println("over");
    
39.         }
    
40. }
    
41. 
    
42. class Div1 {
    
43.         int method(int a, int b) throws FuShuException{                       
    
44.                 if(b < 0)                                                                                                //如果除数小于零
    
45.                         throw new FuShuException("出现了负数———by fushu");        //抛出负数异常，method()方法上也不用声明异常
    
46.                 return a/b;                                                                                               
    
47.         }                                                                                                                       
    
48. }
    
49. 
    
50. class FuShuException extends RuntimeException {                //负数异常继承RuntimeException
    
51.         FuShuException(String message) {                                               
    
52.                 super(message);                                                       
    
53.         }
    
54. }
    
55. */

复制代码

RuntimeException 是属于unchecked （java 编译器允许不catch）表示一类 未知的不确定的只有在运行时才会出现的异常。
而非RuntimeException 是checked （java 编译器必须要求 catch），大概指一类可以预知的，当发生异常后知道如何处理的异常，所以需要捕获。
Java compiler要求所有的Exception 要么被catch,要么被throw，除非这是一个RuntimeExeption (e instanceof RuntimeException)。也就是说，通常的Exception一定要被处理，也即我们所说的 checked exception，而RuntimeException不强制要求处理，（当然你自己要处理也可以），所以我们称为unchecked exception。
之所以区分 checked/unchecked exception，JAVA的设计思想是区分从类/方法设计者角度来看两种不同的异常：
一种是设计者认为这个方法在使用过程中使用者能够处理的异常，这些往往作为checked exception。比如一个IO系统的设计者会认为诸如物理文件不存在或者介质无法读取等异常时很可能发生，而使用者完全可能捕获这个异常，通过让用户 重新输入文件名等方式重新进行这个操作，也就是说，这是一个可恢复的操作。所以我会在诸如 read()/write()等操作中throw 一个 IOException(checked exception)。