java异常处理——笔记总结

首先我们来看一下java异常体系结构图

一、java异常体系
Thorwable类（表示可抛出）是所有异常和错误的超类，两个直接子类为Error和Exception，分别表示错误和异常。

• 其中异常类Exception又分为运行时异常(RuntimeException)和非运行时异常， 这两种异常有很大的区别，也称之为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。

1、Error与Exception

• Error是程序无法处理的错误，它是由JVM产生和抛出的，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

• Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。

2、运行时异常和非运行时异常

• 运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

• 非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

出现问题的情况
1、涉及类型转换的方法
2、涉及内存与CPU，磁盘，网络，以及其他硬件交互的方法
例如JDBC中，需要捕获异常，原因是数据库在磁盘中，而程序是运行在内存上的，涉及了内存与磁盘的交互（不确定磁盘的状态是否良好）
3、数组访问越界
4、访问 null 指针
5、试图在文件尾部后面读取数据
6、试图打开一个不存在的文件
7、试图根据给定的字符串查找Class 对象 ， 而这个字符串表示的类并不存在

try—catch:如果代码运行出现了错误，那么执行catch,但不能影响后边代码运行

public static void main(String[] args) {
		int[] a = new int[5];
		try {
			for (int i = 0; i <10; i++) {
				a[i] = i;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		System.out.println("----------------");
	}

throws:向外抛出异常，让之后一个接受到该异常的方法区处理

public static void main(String[] args) {
		
		Test test = new Test();
		try {
			test.run();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("--------------");
		
	}
	
	public void run() throws CloneNotSupportedException {
		this.sun();
	}
	
	public void sun() throws CloneNotSupportedException {
		User user01 = new User();
		User user02 = user01.clone();
		System.out.println(user01);
		System.out.println(user02);
		user01.ChangedPerson("李四");
		System.out.println(user01.getPerson());
		System.out.println(user02.getPerson());
	}

抛出异常的步骤如下

2、 try、catch、finally三个语句块应注意的问题
第一：try、catch、finally三个语句块均不能单独使用，三者可以组成 try…catch…finally、try…catch、try…finally三种结构，catch语句可以有一个或多个，finally语句最多一个。
第二：try、catch、finally三个代码块中变量的作用域为代码块内部，分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。
第三：多个catch块时候，最多只会匹配其中一个异常类且只会执行该catch块代码，而不会再执行其它的catch块，且匹配catch语句的顺序为从上到下，也可能所有的catch都没执行。
第四：先Catch子类异常再Catch父类异常。

finally、final、finalize()的区别
finally 异常中总能执行的代码区
final 用于定义常量的关键字
finalize() 垃圾回收，该方法是系统调用，不用程序员手动调用
3、throws和throw的区别
throws关键字
定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常，而交给方法调用处进行处理。
throws关键字格式：

public class ThrowsDemo01 {
	 public static void main(String args[]){
	        Math m = new Math() ;        // 实例化Math类对象
	        try{
	            System.out.println("除法操作：" + m.div(10,2)) ;
	        }catch(Exception e){
	            e.printStackTrace() ;    // 打印异常
	        }
	    }
}
class Math{
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        int temp = i / j ;    // 计算，但是此处有可能出现异常
        return temp ;
    }
};

因为div使用了throws关键字声明，所以调用此方法的时候，方法必须进行异常处理。
如果在主方法的声明也使用了throws关键字呢，那么是不是意味着主方法也可以不处理异常呢？

public class ThrowsDemo01 {
	 public static void main(String args[]) throws Exception{
	        Math m = new Math() ;        // 实例化Math类对象
	        System.out.println("除法操作：" + m.div(10,0)) ;
            System.out.println("我还可以输出");
	    }
}
class Math{
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        int temp = i / j ;    // 计算，但是此处有可能出现异常
        return temp ;
    }
};

在本程序中，主方法不处理任何异常，而交给JAVA中最大头JVM，所以如果在主方法使用了throws关键字，则表示一切异常交给JVM进行处理。

throw关键字
throw关键字作用是抛出一个异常，抛出的时候是一个异常类的实例化对象，
在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

package methoud;
public class ThisDemo06{
    public static void main(String args[]){
        try{
            throw new Exception("自己抛着玩的。") ;    // 抛出异常的实例化对象
        }catch(Exception e){
            System.out.println(e) ;
        }
    }
};

通过 throw new来抛出新的异常锁定出错位置

package com.qcby.Test0306;

public class Test {
    public static void main(String[] args) {
        try {
            int a1 = change("123");
            int a2 = change("143");
            System.out.println(13);
            int a3 = change("163gjhk");
        } catch (Exception e) {
            //getMessage()获取错误信息
            System.out.println("错误原因："+e.getMessage());
        }finally {

        }
    }
    //将异常抛给调用者
    public static Integer change(String x) throws Exception{
        try{
            return Integer.parseInt(x);
        }catch (Exception e){
            //抛出新的异常
            throw new Exception("传进来的参数有问题，参数值是，"+x);
        }finally {
            //finally是一定执行的，即使是在try区域种有return存在
            System.out.println("==========");
        }

    }
}

finally是一定执行的，即使是在try区域种有return存在
在finally中一般写的是IO操作的关闭，保证执行

Exception e这个变量是在同一个线程内被共享的（作用域），ThreadLocal也是

package com.qcby.Test0306;

public class Test1 {
    public static void main(String[] args) {
        m1();
    }
    public static void m1(){
        m2();
    }
    public static void m2(){
        try {
            m3();
        } catch (Exception e) {
            //在一个线程内共享e.getMessage()
            System.out.println(e.getMessage()+"我是m2");
        }
    }
    public static void m3() throws Exception {
        m4();
    }
    public static void m4() throws Exception {
        m5();
    }
    public static void m5() throws Exception{
        throw new Exception("我有病");
    }
}