【Java】异常处理

异常的定义

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。 （开发过程中的语法错误和逻辑错误不是异常）

1. 异常的体系结构

Java程序在执行过程中所发生的异常事件可分为两类：

1. Error：Java虚拟机无法解决的严重问题。

如：JVM系统内部错误、资源耗尽等严重情况。

比如： StackOverflowError和OOM。一般不编写针对性的代码进行处理。

1. Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
   • 空指针访问
   • 试图读取不存在的文件
   • 网络连接中断
   • 数组角标越界

• Error（错误）：表示系统级的错误和程序不必处理的异常，一般是指与虚拟机相关的问题，是Java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
• Exception（异常）：表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。

Exception又分为运行时异常，受检查异常。

• 运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。
• 受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

异常的体系结构

 * java.lang.Throwable
 * 		|-----java.lang.Error:一般不编写针对性的代码进行处理。
 * 		|-----java.lang.Exception:可以进行异常的处理
 * 			|------编译时异常(checked)不会生成字节码文件
 * 					|-----IOException
 * 						|-----FileNotFoundException
 * 					|-----ClassNotFoundException
 * 			|------运行时异常(unchecked,RuntimeException)
 * 					|-----NullPointerException//空指针异常
 * 					|-----ArrayIndexOutOfBoundsException//数组角标越界
 * 					|-----ClassCastException//类型转化异常
 * 					|-----NumberFormatException//编码格式异常
 * 					|-----InputMismatchException//输入不匹配
 * 					|-----ArithmeticException//算术异常

java中异常类的继承关系



蓝色：非受检(unchecked)异常

红色：受检(checked)异常

2. 按照异常发生的时间可以分为两类

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

技巧：所以当程序需要模拟异常发生的时候，我们可以使用throw new RuntimeException("test")来直接抛出不用额外处理的运行时异常。

3.常见的异常类型

//******************以下是运行时异常***************************
	//ArithmeticException
	@Test
	public void test6(){
		int a = 10;
		int b = 0;
		System.out.println(a / b);
	}

	//InputMismatchException
	@Test
	public void test5(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);

		scanner.close();
	}

	//NumberFormatException
	@Test
	public void test4(){

		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);
	}

	//ClassCastException
	@Test
	public void test3(){
		Object obj = new Date();
		String str = (String)obj;
	}

	//IndexOutOfBoundsException
	@Test
	public void test2(){
		//ArrayIndexOutOfBoundsException
//		int[] arr = new int[10];
//		System.out.println(arr[10]);
		//StringIndexOutOfBoundsException
		String str = "abc";
		System.out.println(str.charAt(3));
	}

	//NullPointerException
	@Test
	public void test1(){
//		int[] arr = null;
//		System.out.println(arr[3]);

		String str = "abc";
		str = null;
		System.out.println(str.charAt(0));

	}

	//******************以下是编译时异常***************************
	@Test
	public void test7(){
//		File file = new File("hello.txt");
//		FileInputStream fis = new FileInputStream(file);
//
//		int data = fis.read();
//		while(data != -1){
//			System.out.print((char)data);
//			data = fis.read();
//		}
//
//		fis.close();

	}

异常的处理

1. java异常处理的抓抛模型

过程一："抛"：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生：

① 系统自动生成的异常对象

② 手动的生成一个异常对象，并抛出（throw）

过程二："抓"：可以理解为异常的处理方式：① try-catch-finally ② throws

2.异常处理方式一：try-catch-finally

2.1 使用说明：

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结构以后，就不能再被调用

7. try-catch-finally结构可以嵌套

如何看待代码中的编译时异常和运行时异常？

1. 使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
2. 开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

2.2. finally的再说明：

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

测试程序：

public class Test {

    public static void main(String[] args) {
        test();

        print("main");
    }

    public static int test() {
        try {
            print("try");
            return print("try返回");
        } catch (Exception e) {
            e.printStackTrace();
            print("catch");
            return print("catch返回");
        } finally {
            print("finally");
            return print("finally返回");

        }
    }

    public static int print(String x) {
        System.out.println(x);
        return 0;
    }

}

运行结果：

try
try返回
finally
finally返回
main

也就是说，即使try中要返回，那也得执行finally，再出去。

try里面的return不会出现终止现象，finally不管怎么着都会执行，return只是他们之间的一个约定，预约要出去了，但是在出去前执行finally。

try只是尝试去执行，finally才是最后一定会执行的。

try如果中途有return，那么也只是尝试返回，预约一下要返回了，出去前执行完finally再出去。

try、catch、finally的执行顺序

异常处理中，try、catch、finally的执行顺序，大家都知道是按顺序执行的。即，如果try中没有异常，则顺序为try→finally，如果try中有异常，则顺序为try→catch→finally。但是当try、catch、finally中加入return之后，就会有几种不同的情况出现，下面分别来说明一下。也可以跳到最后直接看总结。

一、try中带有return

     private int testReturn1() {
         int i = 1;
         try {
             i++;
             System.out.println("try:" + i);
             return i;
         } catch (Exception e) {
             i++;
             System.out.println("catch:" + i);
         } finally {
             i++;
             System.out.println("finally:" + i);
         }
         return i;
     }

输出：

try:2
finally:3
2

因为当try中带有return时，会先执行return前的代码，然后暂时保存需要return的信息，再执行finally中的代码，最后再通过return返回之前保存的信息。所以，这里方法返回的值是try中计算后的2，而非finally中计算后的3。但有一点需要注意，再看另外一个例子：

    private List<Integer> testReturn2() {
         List<Integer> list = new ArrayList<>();
         try {
             list.add(1);
             System.out.println("try:" + list);
             return list;
         } catch (Exception e) {
             list.add(2);
             System.out.println("catch:" + list);
         } finally {
             list.add(3);
             System.out.println("finally:" + list);
         }
         return list;
     }

输出：

try:[1]
finally:[1, 3]
[1, 3]

看完这个例子，可能会发现问题，刚提到return时会临时保存需要返回的信息，不受finally中的影响，为什么这里会有变化？其实问题出在参数类型上，上一个例子用的是基本类型，这里用的引用类型。list里存的不是变量本身，而是变量的地址，所以当finally通过地址改变了变量，还是会影响方法返回值的。

二、catch中带有return

     private int testReturn3() {
         int i = 1;
         try {
             i++;
             System.out.println("try:" + i);
             int x = i / 0 ;
         } catch (Exception e) {
             i++;
             System.out.println("catch:" + i);
             return i;
         } finally {
             i++;
             System.out.println("finally:" + i);
         }
         return i;
     }

输出：

try:2
catch:3
finally:4
3

catch中return与try中一样，会先执行return前的代码，然后暂时保存需要return的信息，再执行finally中的代码，最后再通过return返回之前保存的信息。所以，这里方法返回的值是try、catch中累积计算后的3，而非finally中计算后的4。

三、finally中带有return

     private int testReturn4() {
         int i = 1;
         try {
             i++;
             System.out.println("try:" + i);
             return i;
         } catch (Exception e) {
             i++;
             System.out.println("catch:" + i);
             return i;
         } finally {
             i++;
             System.out.println("finally:" + i);
             return i;
         }
     }

输出：

try:2
finally:3
3

当finally中有return的时候，try中的return会失效，在执行完finally的return之后，就不会再执行try中的return。这种写法，编译是可以编译通过的，但是编译器会给予警告，所以不推荐在finally中写return，这会破坏程序的完整性，而且一旦finally里出现异常，会导致catch中的异常被覆盖。

总结：

1、finally中的代码总会被执行。

2、当try、catch中有return时，也会执行finally。return的时候，要注意返回值的类型，是否受到finally中代码的影响。

3、finally中有return时，会直接在finally中退出，导致try、catch中的return失效。

https://www.cnblogs.com/pcheng/p/10968841.html

---

try-with-resources

在java7之后，可以使用try-with-resources语句来释放java流对象，从而避免了try-catch-finally语句的繁琐，尤其是在finally子句中，close()方法也会抛出异常。

try-catch-finally

@Test
public void testDemo2() {
    Scanner scanner = null;
    try {
        scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"));       //这里的路径一定要写完整路径
        while (scanner.hasNext()) {
            System.out.println(scanner.nextLine()); //逐行读取
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        //读取完毕则关闭
        if (scanner != null) {
            scanner.close();
        }
    }
}

try-with-resource，try(AutoCloseable类对象)

@Test
public void testDemo3() {
    try (Scanner scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"))) {
        while (scanner.hasNext()) {
            //逐行读取文件中的内容
            System.out.println(scanner.nextLine());
        }
    } catch (FileNotFoundException file) {
        file.printStackTrace();
    }
}

使用try-with-resource关闭多个资源，多个资源使用;隔开

@Test
public void testDemo4() {
    try (Scanner scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"));
        PrintWriter writer = new PrintWriter(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\testWrite.txt"))
    ) {
        while (scanner.hasNext()) {
            //test.txt文件的内容写入到test2中
            writer.println(scanner.nextLine());
        }
    } catch (FileNotFoundException file) {
        file.printStackTrace();
    }
}

3. 异常处理方式二：

"throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。 一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后的异常类型时，就会被抛出给上游调用者。异常代码后续的代码，就不再执行！

适用场景

适用于本方法不知道如何处理，只有调用方才可能知道如何处理异常；

例如：一些底层的方法，其可能出现多种异常，且调用方可能根据不同的异常做出不同的处理，只能抛出异常，而且必须是具体的异常类型，而不能是笼统的Exception类型。

理解：如果一些业务代码从上到下都是自己写的，那就大可不必throws异常，在遇到异常的时候直接catch处理就行了，不用一层一层向外抛。

比如说，现在我这个底层方法需要解析一个日期，可能会遇到解析异常，那么我就需要声明可能会遇到的异常，交给调用者去处理。

调用者有可能说，如果解析失败，那就默认取当前的日期。

4. 对比两种处理方式

• try-catch-finally:真正的将异常给处理掉了。
• throws的方式只是将异常抛给了方法的调用者。并没真正将异常处理掉。

5. 开发中应该如何选择两种处理方式？

• 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
• 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。这几个方法中，都会有各自的异常出现。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

理解：因为那几个方法中如果使用的是 try-catch-finally，那样的话，其中如果有异常，就会被 catch 住，在本方法中处理掉了，而不会被方法a所察觉。方法a还是会继续往下执行，然而其中已经有方法出现异常了，就没有向下执行的必要了。

所以我们需要将那几个方法的异常给throws抛出来，这样才会被我们的外层方法a所察觉。

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

手动抛出异常对象

1.使用说明

在程序执行中，除了自动抛出异常对象的情况之外，我们还可以手动的throw一个异常类的对象。

2.经典面试题

throw 和 throws区别： throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。 throws 属于异常处理的一种方式，声明在方法的声明处。

3.代码示例

class Student{

	private int id;

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

		}
	}

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

}

自定义异常类

1.如何自定义异常类

1. 继承于现有的异常结构：RuntimeException 、Exception
2. 提供全局常量：serialVersionUID（对类的唯一标识）
3. 提供重载的构造器

2.代码示例

public class MyException extends Exception {

	static final long serialVersionUID = -7034897193246939L;

	public MyException() {

	}

	public MyException(String msg) {
		super(msg);
	}

    // 自定义异常，不要丢掉原始的异常信息
    public MyException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 使用示例
public void someMethod() {
    try {
        // 原始可能抛出异常的代码
    } catch (Exception originalException) {
        // 包装原始异常到自定义异常
        throw new MyException("自定义异常信息", originalException);
    }
}

实例

捕获但不处理异常

在开发过程中，我们可能会遇到异常情况，但不需要中断处理。

例如，在数据批量处理的for循环中，我们某一个数据处理中出现了异常，但是其实并不需要中断处理，应该继续向下去处理其他数据。

try {
	test();
} catch (Exception e) {
	log.error("有异常，但是不处理", e);
	// 这里不需要中断处理，所以不要抛出异常
	// throw new RuntimeException(e);
}