面试常问的异常体系

1.java异常体系

        异常体系中最大的类Throwable类。

2.Error类

        我们看到的错误就是它产生的具体对象。

        Error是程序无法处理的错误，它由jvm产生和抛出。

        OutOfMerroryError：内存溢出

        ThreadDeath：线程锁死，不释放一直占用着资源。

        这些异常发生时，jvm就会终止程序。

3.Exception类

        异常是程序本身可以处理的。 通常分为运行时异常和非运行时异常。

        非运行时异常（受检异常）：在编译的时候可能就会产生的异常，不在运行java命令之后发生，而是在运行javac命令的时候发生（就是在编译器编写的时候就会报错，报红线）。非运行时异常是RunTimeException以外的异常，类型都是属于Exception类。常见的有SQLException，IOException（输入输出，咱们当时上传图片就涉及到这个异常）或者程序员自定义的异常都是非运行时异常。这些异常程序必须处理。

        运行时异常（非受检异常）：执行了java命令之后，发生的异常。运行时异常都是RunTimeException这个类或者其子类。常见的有NullPointerException(空指针异常，不运行的时候不会报错，运行了才能看见)；IndexOutOfBoundsException(数组越界)；ArithmeticException（除0异常，10/0）。这些异常程序可以选择处理，或者不选择处理。

4.异常处理方式

        有异常不处理的后果：程序终止。

        一个catch块中只能监听一种类型。

        处理异常这两种没有类型区别，任何异常都可以适用，只不过推荐try...catch。

        方式：

                ①try...catch

                        这种属于自己处理，有责任心。

                        一个catch块中只能监听一种类型。

public class Test {
	public static void main(String[] args) {
		int[] a = new int[5];
		try {
			for(int i = 0; i < 10;i++) {  //加上try...catch之后就算出错也会执行下面的初始化成功字样
				a[i] = i;
			}
		}catch(Exception e){  //也可以填ArrayIndexOutOfBoundsException这个类，这采用多态写法，是Exception的子类，但结果没区别
			e.printStackTrace();
		}
		
		
		System.out.println("-----初始化成功-----------");
	}
}

 

        ②throws抛出

                这种只是抛出去（甩锅），让之后调用该异常方法的方法进行处理，如果只是抛的话，每一级都需要处理该异常。

                如果在main中这种错误真的发生了，还是继续往上抛的话，就会交给jvm，那么程序就会终止，后果严重。

public class Test1 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Test1 t1 = new Test1(); //如果方法是静态方法就可以取消这一步了
		t1.run();
	}
	
	public void run() throws CloneNotSupportedException {
		sun();
	}
	
	//处理异常的另一种方式throws  抛出异常
	public void sun() throws CloneNotSupportedException {
		User user1 = new User();
		user1.clone();
	}
}

5.try...catch...finally

        catch中的语句，只有异常发生了，catch中的语句才会执行。而finally无论是否发生异常，都会执行里面的语句。

使用注意事项：

        ①try...catch...finally均不能单独使用，但是可以组合使用。

        ②组合的结构有三种：try...catch...finally；try...catch；try...finally

        ③catch块可以有好多个，但是finally最多有一个。

try {
	for(int i = 0; i < 10;i++) {  //加上try...catch就会出错也会执行下面的初始化成功字样
	    a[i] = i;
	}
    }catch(ArrayIndexOutOfBoundsException e){  
			
    }catch(Exception e){ 
		e.printStackTrace();
    }finally {
		System.out.println("111");
    }

        ④catch块有多个 的时候，优先匹配子类异常，在写父类异常，否则会报错，写的时候也是先写子类再写父类。

        ⑤多个catch块的时候，最多只会匹配一个catch块，而不再执行其他catch块，且catch块的匹配顺序是从上到下的，也可能所有catch块都不执行（没有发生错误的时候）。

        ⑥try...catch...finally中的变量均为局部变量，不能相互访问。

try {
	//int b;
	for(int i = 0; i < 10;i++) {  //加上try...catch就会出错也会执行下面的初始化成功字样
		a[i] = i;
    }
    }catch(ArrayIndexOutOfBoundsException e){  //也可以填ArrayIndexOutOfBoundsException这个类，这采用多态写法，是Exception的子类，但结果没区别
        //System.out.println(b); //b无法访问，因为try中的是局部变量
        e.printStackTrace();  //整个错误信息打印出来  e.getMessage()错误的备注信息，如by zero
    }

6.throws与throw

        throws关键字 声明的方法表示该方法不处理异常，而是交给方法的调用者。可以主动加，比如除0异常只有运行的时候才会报错，为了以防万一，可以抛出异常，这样会使调用该异常方法的方法强制处理。

        throw关键字 作用是抛异常，抛出的时候是一个异常类的实例化对象

public class Test3 {
	public static void main(String[] args) {
//		Math math = new Math();
//		try {
//			math.div(10, 0);
//		}catch(Exception e){
//			System.out.println(e.getMessage());
//		}
		
		try {
			throw new Exception("自己抛着玩"); //自己写的一个错误，非运行异常，只能抛一个异常对象
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
		
	}
}
class Math{
	public int div(int i,int j) throws Exception,ArithmeticException{  //可以跟多个异常类名
		int temp = i/j;
		return temp;
	}
}

区别：

        throws：是用来声明一个方法可能产生的异常，不作任何处理而是将异常向上传递，谁调用抛给谁，谁处理。

                ①用在方法声明后面，跟的是异常类

                ②可以跟多个异常类名，用逗号隔开

                ③表示抛出异常，由该方法的调用者处理

                ④throws表示出现异常的一种可能性，不一定发生异常

        throw：是用来抛出一个具体的异常

                ①用在方法体内，跟的是异常类对象

                ②只能抛一个异常对象

                ③表示抛出异常，由方法体内的语句处理

                ④throw抛出异常，是一定会发生的异常（自己写的异常错误，当然是一定发生）