关于Java中的异常处理（详细）

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理

Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：

• 空指针访问
• 试图读取不存在的文件
• 网络连接中断
• 数组角标越界

对于这些错误，一般有两种解决方法：

• 一是遇到错误就终止程序的运行。
• 另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。比如：除数为0，数组下标越界等

异常分类：编译时异常和运行时异常

运行时异常
是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。
编译时异常
是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
对于这类异常，如果程序不处理，可能会带来意想不到的结果。

java异常体系结构
 * 
 * java.lang.Throwable
 *         |----java.lang.Error:一般不编写针对性的代码进行处理
 *         |----java.lang.Exception:可以进行异常处理
 *             |----编译时异常(checked)
 *                 |----IOEXception
 *                     |----FileNotFoundException
 *                 |----ClassNotFoundException
 *             |----运行时异常(unchecked)
 *                 |----NullPointerException
 *                 |----ArrayIndexOutOfBoundsException
 *                 |----ClassCaseException
 *                 |----NumberFormatException
 *                 |----InputMismatchException
 *                 |----ArithmaticException

异常处理机制一：try-catch-finally
在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。

Java异常处理:

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

方式一：try-catch-finally

方式二：throws + 异常类型

Java异常处理的方式: try-catch-finally

try
捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
catch(Exceptiontypee)
在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
捕获异常的有关信息：与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
getMessage() 获取异常信息，返回字符串
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void

finally
捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
finally语句和catch语句是任选的

 异常的处理:抓抛模型
 * 
 * 过程一:“抛”：程序在征程执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象
 *              并将此对象抛出。
 *             一旦抛出对象以后，其后的代码就不再执行。
 * 
 * 过程二:“抓”:可以理解为异常的处理方式：① try-catch-finally  ② throws
 * 
 * 二、try-catch-finally的使用
 * 
 * try{
 *         //可能出现异常的代码
 * }catch(异常类型1 变量名1){
 *         //处理异常的方式1
 * }catch(异常类型2 变量名2){
 *         //处理异常的方式2
 * }catch(异常类型3 变量名3){
 *         //处理异常的方式3
 * }
 * ...
 * finally{
 *         //一定会执行的代码
 * }
 * 
 * 说明:
 * 1.finally是可选的。
 * 2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象
 *   的类型，去catch中进行匹配。
 * 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的
 *   try-catch结构（在没有写finally的情况）。继续执行其后的代码。
 * 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
 *   catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
 * 5.常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()
 * 6.在try结构中声明的变量，再出了try结构以后，就不能再被调用,例65行:System.out.println(num);
 * 7.try-catch-finally结构可以嵌套  
 * 
 * 体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。
 *     相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
 *     
 * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
 *      针对于编译时异常，我们说一定要考虑异常的处理。

try-catch-finally中finally的使用：
 * 
 * 1.finally是可选的。
 * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
 *   return语句等情况。
 * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的
 *   释放。此时的资源释放，就需要声明在finally中。

异常处理机制二：throws

声明抛出异常是Java中处理异常的第二种方式
如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

/*
 * 异常处理的方式二：throws + 异常类型
 *
 * 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
 *     一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
 *     类型时，就会被抛出。异常代码后续的代码，就不再执行！
 *
 *     关于异常对象的产生:① 系统自动生成的异常对象
 * 					② 手动生成一个异常对象，并抛出(throw)
 *
 * 2. 体会：try-catch-finally:真正的将异常给处理掉了。
 *        throws的方式只是将异常抛给了方法的调用者。  并没有真正将异常处理掉。
 *
 */
public class ExceptionTest2 {

	public static void main(String[] args){
		try {
			method2();
		} catch (IOException e) {
			e.printStackTrace();
		}

		method3();
	}

	public static void method3(){
		try {
			method2();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void method2() throws IOException{
		method1();
	}

	public static void method1() throws FileNotFoundException,IOException{
		File file = new File("hello1.txt");
		FileInputStream fis = new FileInputStream(file);

		int data = fis.read();
		while(data != -1){
			System.out.print((char)data);
			data = fis.read();
		}

		fis.close();

		System.out.println("hahaha!");
	}
}

* 异常处理的方式二：throws + 异常类型
 * 
 * 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
 *     一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
 *     类型时，就会被抛出。异常代码后续的代码，就不再执行！
 *
 *     关于异常对象的产生:① 系统自动生成的异常对象
 *                     ② 手动生成一个异常对象，并抛出(throw)
 *     
 * 2. 体会：try-catch-finally:真正的将异常给处理掉了。
 *        throws的方式只是将异常抛给了方法的调用者。  并没有真正将异常处理掉。  
 *

 方法重写的规则之一： * 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

/* . 开发中如何选择使用try-catch-finally 还是使用throws？
 *    如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果
 *       子类重写的方法中有异常，必须使用try-catch-finally方式处理。
 *    执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws
 *       的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
 */

用户自定义异常类

/**
 * 自定义受控异常（编译时、检查时异常（checkedException）），继承Exception
 */
class MyCheckedException extends Exception {

    public MyCheckedException() {
        //调用父类的默认构造函数
        super();
    }

    public MyCheckedException(String message) {
        //手动调用父类的构造方法
        super(message);
    }

}

/**
 * 使用自定义异常
 */
public class MyExceptionClass {

    public static void main(String[] args) {
        testException1();
        testException2();
    }

    private static void testException1() {
        //【示例代码】自定义受控异常的使用
        try {
            method1(10, 0);
        } catch (MyCheckedException e) {
            //必须拦截,拦截后建议给出处理，如果不给出处理，就属于隐藏了该异常
            //系统将不给出任何提示，使程序的调试非常困难
            System.out.println(e.getMessage());
        }
    }

    private static void testException2() {
        method2(10, 0);
    }

    /**
     * 自定义受控异常的使用
     * 如果是受控异常必须throws声明，让调用方处理异常
     *
     * @param value1
     * @param value2
     * @throws MyCheckedException
     */
    private static void method1(int value1, int value2) throws MyCheckedException {
        if (value2 == 0) {
            throw new MyCheckedException("方法1，自定义受控异常，除数不能为0！");
        }
        int value3 = value1 / value2;
        System.out.println(value3);
    }

    /**
     * 【示例代码】，自定义非受控异常的使用
     *
     * @param value1
     * @param value2
     */
    private static void method2(int value1, int value2) {
        //throws MyRuntimeException {
        if (value2 == 0) {
            //抛出非受控异常，方法可以不使用throws进行声明，但也可以显示的声明
            throw new MyRuntimeException("方法2，自定义非受控异常，除数不能为0！");
        }
        int value3 = value1 / value2;
        System.out.println(value3);
    }

}

• 一般地，用户自定义异常类都是RuntimeException的子类。
• 自定义异常类通常需要编写几个重载的构造器。
• 自定义异常需要提供serialVersionUID
• 自定义的异常通过throw抛出。
• 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型

* 如何自定义异常类？ * 1.继承于现有的异常结构：RuntimeException 、Exception * 2.提供全局常量：serialVersionUID * 3.提供重载的构造器

public static void main(String[] args) {
        NullPointerException e=new NullPointerException("空指针异常");

        String msg=e.getMessage();//获取异常的信息，这个信息实际上就是构造方法上面String参数
        System.out.println(msg);

        e.printStackTrace();//java后台打印异常堆栈追踪信息时，采用异步线程方式打印
    }

/*
输出
空指针异常
java.lang.NullPointerException: 空指针异常
	at ExceptionTest.main(ExceptionTest.java:7)
*/

public class StudentTest {
	public static void main(String[] args) {
		try {
			Student s = new Student();
//		s.regist(1001);
			s.regist(-1001);
			System.out.println(s);
		} catch (Exception e) {
//			e.printStackTrace();
			System.out.println(e.getMessage());
		}
	}
}
class Student{
	private int id;

	public void regist(int id) throws Exception{
		if(id > 0){
			this.id = id;
		}else{
//			System.out.println("您输入的数据非法！");
			//手动抛出异常
//			throw new RuntimeException("您输入的数据非法！");//抛出一个异常的对象
			throw new Exception("您输入的数据非法！");

		}
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}

}

getMessage（）

获取异常简单的描述信息

printStackTrace（）

打印异常追踪的堆栈信息

throw 和 throws 的区别？
throw
throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。

throw是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行throw一定是抛出了某种异常。

throw一般用于抛出自定义异常。

throws
throws语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。

throws主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。

throws表示出现异常的一种可能性，并不一定会发生这种异常。

 final、finally、finalize 的区别？
final
用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。

finally
异常处理语句结构的一部分，表示总是执行。

finalize
finalize 是Object 类的一个方法，所以Java对象都有这个方法，当某Java对象没有更多的引用指向的时候，会被垃圾回收器回收，该对象被回收之前，由垃圾回收器来负责调用此方法，通常在该方法中进行回收前的准备工作。该方法更像是一个对象生命周期的临终方法，当该方法被系统调用则代表该对象即将“死亡”，但是需要注意的是，我们主动行为上去调用该方法并不会导致该对象“死亡”，这是一个被动的方法（其实就是回调方法），不需要我们调用。

public static int getNum() {
        try {
            int a = 1 / 0;
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {
            return 3;
        }
    }
   public static void main(String[] args) {
        System.out.println(getNum());
}

上述代码调用后，返回的结果是3，代码分析如下：

//代码走到第 3 行的时候遇到了一个MathException，这时第 4 行的代码就不会执行了，代码直接跳转到catch语句中，走到第 6 行的时候，
        //异常机制有一个原则：如果在catch中遇到了return或者异常等能使该函数终止的话那么有finally就必须先执行完finally代码块里面的代码然后再返回值。
        //因此代码又跳到第 8 行，可惜第 8 行是一个return语句，那么这个时候方法就结束了，因此第 6 行的返回结果就无法被真正返回。
        //如果finally仅仅是处理了一个释放资源的操作，那么该道题最终返回的结果就是2，因此上面这道题返回值是3。

关于一些try-catch-finally执行顺序问题try,catch,finally的执行顺序（超详细）_JavaTeachers的博客-CSDN博客