异常

异常的概述

1.1什么是异常？

异常：程序在运行过程中发生由于外部问题导致的程序异常事件，发生的异常会中断程序的运行。（在Java等面向对象的编程语言中）异常本身是一个对象，产生异常就是产生了一个异常对象。注意在java中异常不是错误，在下文的异常的分类中有解释。

1.2 如何处理异常？

1.2.1 传统的异常处理

假如现在要求在控制台中，输入被除数和除数，求商。

传统做法是这样的：

public static void main(String[] args) {
	System.out.println("请输入一个被除数:");
	Scanner sc = new Scanner(System.in);
		int num1 = sc.nextInt;
		System.out.println("请输入一个除数:");
		int num2 = sc.nextInt;
			if(num2== 0) {
				System.out.println("除数不能为0！");
			}else {
				int r = num1 / num2;
				System.out.println("r = " + r);
			}
}

从上面这个例子可以可以看出，这么简单的业务需求，代码也要写得那么长，因为要考虑的问题有很多，这样写代码会觉得很累，而且出现了异常，程序会中断，不会执行后面的代码。因此，Java编程语言使用异常处理机制为程序提供异常处理的能力。

1.2.2 java的异常处理

在Java中，异常处理的过程：
这种处理过程就像你上班遇到公路施工，你做出了处理——绕路行走，避开施工路段，让你按时到达公司！

2.异常的分类

在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

***Error（错误）***:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

***Exception（异常）***:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。

受查异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。受查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

运行时异常（RuntimeException）:本身和其子类均为运行时异常，可处理可不处理。

不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。

Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

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

3.异常处理机制

通过上面对异常的解释，现在应该对异常有一定的了解。下面来说明在java中是如何处理异常的。

•在java中用对象来表示异常的。

•java是通过
try{}-catch(){}、
try{}-catch(){}-finally{}、
try{}-catch(){}-catch(){}…finally{}、
try{} - finally{}语句来处理异常的。

3.1 try-catch

3.1.1 try-catch的使用

try{} 代码块用于执行可能存在异常的代码，catch(异常类型 异常对象的名称){}代码块用于捕获并处理异常。

try{

//有可能出现异常的代码段1

//有可能出现异常的代码段2

}catch(异常类型 e){

//处理异常的代码段3

}

//代码段4

处理两数相除问题的demo：

public static void main(String[] args) {

	Scanner sc = new Scanner(System.in);
	
	try{
	
		System.out.println("请输入一个被除数:");
	
		int num1=sc.nextInt;
	
		System.out.println("请输入一个除数:");
	
		int num2=sc.nextInt;
	
		int result=num1/num2;
	
	}catch(Exception e){
	
		System.out.println("除数不能为0");//处理异常，通俗的说就是自己划定规则
	
	}
	System.out.println(result);

	System.out.println("程序运行结束");

}

3.1.2 try-catch的执行顺序

第一种：没有遇到异常，即正常执行

第二种：匹配到异常

在try{}中的代码遇到异常时，会与catch中括号里的异常进行比对，如果遇到的异常时属于catch的异常就会执行catch块中的代码，让后执行try-catch块后面的代码

第三种：匹配不到异常

3.2try-catch-finally

try{} 代码块用于执行可能存在异常的代码，catch{}代码块用于捕获并处理异常。

finally{} 代码块用于回收资源(关闭文件、关闭数据库、关闭管道)的代码。finally代码块不管是否出现异常，都必须执行（ finally块唯一不执行的情况System.exit(0) jvm正常退出。）

3.1.1 try-catch-finally的执行顺序

第一种：catch块没有return语句

（1）没有遇到异常：

try块内的代码——>finally块内的代码——>finally块后的代码

（2）遇到异常并匹配到异常：

try块内的代码——>catch块内的代码——>finally块内的代码——>finally块后的代码

public class Test01 {

	public static void main(String[] args) {
	
		try {
		
			int a=1/0;
		
			System.out.println("try");
		
		} catch (Exception e) {
		
			System.out.println("catch");
		
		}finally {
		
			System.out.println("finally");
		
		}
		
		System.out.println("程序正常运行结束");
	
	}

}

结果：

1 catch

2 finally

3 程序正常运行结束

（3）遇到异常却没有匹配到异常：

try块内的代码——>finally块内的代码——>程序中断运行

public static void main(String[] args) {

	try {
	
		int a=1/0;//会抛出ArithmeticException
		
		System.out.println("try");
	
	} catch (NullPointerException e) {
	
		System.out.println("catch");
	
	}finally {
	
		System.out.println("finally");
	
	}
	
		System.out.println("程序正常运行结束");

}

结果：

1 Exception in thread “main” finally

2 java.lang.ArithmeticException: / by zero

3 at Test1.Test01.main(Test01.java:8)

第二种：catch块有return语句

（1）没有异常

try块内的代码——>finally块内的代码——>try块内的return语句

public class Test01 {
	public static int test {	
		try {		
			int a=2*2;		
			System.out.println("try");		
			return a;		
		} catch (Exception e) {
			System.out.println("catch");		
			return 0;		
		}finally {	
			System.out.println("finally");
	}
	
	}
	
	public static void main(String[] args) {
	
	System.out.println(test);
	
	System.out.println("程序正常运行结束");
	
	}

}

结果：

1 try

2 finally

3 4

4 程序正常运行结束

（2）遇到异常并匹配到异常：

执行顺序如图：

public class Test01 {

	public static int test() {
	
		try {
		
			int a=2/0;
		
		System.out.println("try");
		
			return a;
			
		} catch (Exception e) {
		
			System.out.println("catch");
		
			return 0;
		
		}finally {
		
			System.out.println("finally");
		
	}
	
	}
	
	public static void main(String[] args) {
	Test01 test = new Test01();
		
	System.out.println(test.test());
	
	System.out.println("程序正常运行结束");
	
	}

}

结果：

1 catch

2 finally

3 0

4 程序正常运行结束

（3）遇到异常却没有匹配到异常：

try块内的代码——>finally块内的代码——>程序中断运行

public class Test01 {

	public static int test() {
	
		try {
		
			int a=2/0;
		
			System.out.println("try");
		
			return a;
		
		} catch (NullPointerException e) {
		
			System.out.println("catch");
		
			return 0;
		
		}finally {
		
			System.out.println("finally");
		
		}
		
	}
		
		public static void main(String[] args) {
		
			Test01 test = new Test01();
		
			System.out.println(test.test());
		
			System.out.println("程序正常运行结束");
	
		}

}

结果：

finally

Exception in thread “main” java.lang.ArithmeticException: / by zero

at Test1.Test01.test(Test01.java:8)

at Test1.Test01.main(Test01.java:19)

4. 声明异常

4.1 throws

当开发者在定义方法时，事先知道方法在调用时会出现异常，但不知道该如何处理，此时可以在该方法上声明异常。表示该方法在调用过程中会出现异常，请调用者自行处理。

在java中使用throws 声明异常。一个方法可以声明多个异常，用,号分割，写法如下：

1 public void test2throws IOException,RuntimeException{

2 //有异常出得代码，在此处没有处理

3 }

4.2 声明异常与方法重载的关系

声明异常和方法重载没有任何关系。

4.3 声明异常与方法重写的关系

•如果父类方法声明了异常(受查时或运行时)，子类方法可以完全遵循父类异常，也可以不声明异常。

•如果父类方法没有声明异常，子类也不声明异常

•如果父类声明了运行时异常，子类可以完全遵循父类异常，也可以不声明异常。

5.抛出异常

当系统异常满足不了开发需要时，开发者可以自行根据需要自行抛出异常。

throw 用于手动抛出异常。

如果一直都没有处理（即没有用try-catch等语句）异常会把异常抛给调用者，一直抛到main函数处，如果在main函数中也没有处理继续在main函数后抛出异常，这时候会抛给jvm处理。如下栗子：

public class Test01 {

public static void test1throws IOException,RuntimeException{

//有异常抛出得代码，在此处没有处理，例如：throw new Exception（“异常信息”）；

}

public static void test2 throws IOException,RuntimeException{

test1;//调用有抛出异常的方法，在此没有处理

}

public static void main(String[] args)throws IOException,RuntimeException {

test2;//main调用有抛出异常的方法，在此没有处理

}

}

注意:

开发者根据自身需要可以选择抛出检查时异常和运行时异常

6. 自定义异常

当JDK 中的异常类型不能满足程序的需要时，可以自定义异常类。

自定义异常步骤:

•[1] 确定异常类型.继承Excepion 或者RuntimeException

•[2] 编写自定义异常类，并实现构造方法

•[3] 在方法需要的地方手动声明并抛出异常。

public class myException extends Exception {

	public myException {
	
		super;
	
	}
	
	public myException(String message) {
	
		super(message);
	
	}
	
	//自定义异常中的方法，以符合自己的需求
	
	public void showInfo {
	
		System.out.println(super.getMessage+"@Line:");
	
	}

}