1.异常分类




（1）运行时异常(checked exception)：继承自java.lang. RuntimeException类

常见5种：

ClassCastException(类型转换异常)

IndexOutOfBoundsException(数组越界)

NullPointerException(空指针)

ArrayStoreException(数据存储异常，操作数组时类型不一致)

还有IO操作的BufferOverflowException异常

（2）非运行时异常(unchecked exception)：继承自java.lang.Exception类

常见：

Java.lang.ClassNotFoundException

Java.lang.NoSuchMetodException

java.io.IOException

2.两种异常的区别：

Checked异常必须被显式地捕获或者传递，而unchecked异常则可以不必捕获或抛出。

Checked异常继承java.lang.Exception类。Unchecked异常继承自java.lang.RuntimeException类。

3. throw，throws，try-catch的联系

（1）throw：自己手动抛出异常。或者说此处一定会出异常。

比如年龄是负的，我们需要自己手动引发异常，这就是throw的作用。

注意：

如果方法fun1()内throw抛出的是非运行时异常，则该方法必须用throws抛出，否则编译不会通过。假如fun2()调用fun1()，要将fun1()放在fun2()的try中或者fun2继续throws，否则也编译不通过。

例如：

[java] view plain copy
public void fun1(int m) throws Exception{  
        int age=m;  
        if (age<0) {  
            throw new Exception();  
        }  
}  
[java] view plain copy
public void fun2() {  
    try {  
        fun1(-1);            
    } catch (Exception e) {  
        System.out.println("年龄不能为负");  
    }  
}  
如果方法fun1()内throw抛出的是运行时异常，fun1既不用throws，fun2也不用try，编译也会通过。例如：

[java] view plain copy
public void fun1(int m){  
    int age=m;  
    if (age<0) {  
        throw new IndexOutOfBoundsException();  
    }  
}  
//这样编译没问题，但运行会崩溃  
public void fun2() {  
     fun1(-1);            
}  
//这样运行，不会崩溃，因为做了处理  
public void fun3() {  
try {  
    fun1(-1);         
} catch (Exception e) {  
    System.out.println("出异常了～");  
}         
}  
因为运行时异常产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。

（3）throws：用在方法声明后，表示方法可能会抛出异常。

如果一个方法会有异常，但你并不想处理这个异常，就在方法名后面用throws,这样这个异常就会抛出，谁调用了这个方法谁就要try- catch处理这个异常，或者继续throws抛出。

总之，用throws抛出非运行时异常的方法，调用它的方法必须try-catch或者继续throws。throws抛出的是运行时异常, 既不用throws，也不用try-catch。

例如：

[java] view plain copy
public class CheckedExceptionMethods   
{   
    // 总异常类，既有checkedException又有RuntimeException，所以其中的checkedException必须处理   
    public void method1() throws Exception   
    {   
        System.out.println("我是抛出异常总类的方法");   
    }   
    // 捕获并处理这个异常   
    public void testMethod1_01()   
    {   
        try   
        {   
            method1();   
        }   
        catch (Exception e)   
        {   
            e.printStackTrace();   
        }   
    }   
    // 把异常传递下去，继续抛出   
    public void testMethod1_02() throws Exception   
    {   
        method1();   
    }   
}  

（4）try{}catch(想要处理的异常种类){}

如果觉得方法内可能会产生异常，可以自己进行处理，调用者就不用再try-catch，例如：
[java] view plain copy
public void fun1() {  
    int[] a={1,2,3};  
    try {  
        System.out.println(a[3]);   
    } catch (Exception e) {  
        System.out.println("数组越界了～");  
    }         
}  
public void fun2() {  
    fun1();  
}  
也可以偷懒不做处理，让调用者处理，例如：  
public static void fun1() throws Exception{  
    int[] a={1,2,3};  
        System.out.println(a[3]);            
}  
public void fun2() {  
    try {  
        fun1();      
    } catch (Exception e) {  
        System.out.println("数组越界了～");  
    }         
}  

6666

很赞