异常处理

链接：Java异常体系

关键字：try，catch，finally，throw，throws

（1）使用try-catch处理异常：

try{
    可能发生异常的语句；
}
catch（InputMismatchException e）{
    System.out.println("输入的数据类型错啦~~")     //自定义处理异常；
}
catch（Exception e）{
    e.printStackTrace();                         // 调用异常对象的方法处理异常；
}

（2）使用try-catch-finally处理异常：

try{
    可能发生异常的语句；
}
catch（InputMismatchException e）{
    System.out.println("输入的数据类型错啦~~")     //自定义处理异常；
}
catch（Exception e）{
    e.printStackTrace();                         // 调用异常对象的方法处理异常；
}
finally{
    System.out.println("欢迎使用本程序~");
}

a、如果try语句块正常执行完毕，不会发生异常，catch中的语句块将会被忽略。

如果try语句块在执行时发生异常，try语句块中剩下的代码将会被忽略，系统会自动生成一个异常对象，

------如果这个异常对象与catch语句块声明的异常相匹配（catch处理的异常类型是这个异常对象的父类或者是相同的异常），则执行相应catch中的语句块，

------如果这个异常在catch语句块中没有被声明，那么方法立刻退出。

b、catch可使用单个也可使用多个，使用多个时，必须按照从子类到父类的顺序，因为系统只会执行与异常类型相匹配的第一个catch语句，如果子类异常放到后面，将得不到执行的机会。

c、catch语句块中可以加入用户自定义处理信息，也可以调用异常对象的处理方法输出异常信息，常用方法如下：

异常对象的方法

void printStackTrace()	输出异常的堆栈信息。堆栈信息包括程序运行到当前类的执行流程，它将输出从方法调用处到异常抛出处的方法调用序列。
String getMessage()	返回异常信息描述字符串，该字符串描述异常产生的原因，是printStackTrace()输出信息的一部分。

d、无论是否发生异常，finally语句块中的代码总能被执行。

e、即使try语句块或者catch语句块中有return语句，finally语句块也会执行。发生异常时的执行顺序是：

执行try语句块或者catch语句块中的return之前的语句，

执行finally语句块中的语句，

执行try语句块或catch中的return语句退出。

f、finally唯一不执行的情况是：在异常处理代码中执行System.exit(1)退出Java虚拟机。

（3）使用throws声明抛出异常：

如果一个方法体抛出了异常，可以用关键字throws来声明某个方法可能抛出的各种异常。throws 可以同时声明多个异常，之间用逗号隔开。

import java.util.InputMismatchException;
import java.util.Scanner;

public class ThrowsTest {
	public static void main(String args[]) {
		try {
			divide();
		} catch (InputMismatchException e) {
			System.out.println("被除数和除数必须为整数！");
		} catch (ArithmeticException e) {
			System.out.println("除数不能为0！");
		} catch (Exception e) {
			System.out.println("其他未知异常！");
		}
	}

	public static void divide() throws Exception {

		Scanner can = new Scanner(System.in);

		System.out.println("输入除数：");
		int a = can.nextInt();

		System.out.println("输入被除数：");
		int b = can.nextInt();

		System.out.println("商是" + a / b);
	}
}

该实例的结果是：

（4）使用throw抛出异常：

除了系统自动抛出异常外，也可以使用关键字throw来自行抛出一个异常。

public class ThrowTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String sex = "ww";
		try {
			setSex(sex);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

	public static void setSex(String sex) throws Exception {
		if ("男".equals(sex))
			System.out.println("性别是男！");
		else if ("女".equals(sex))
			System.out.println("性别是女！");
		else
			throw new Exception("性别必须是男或者女！");

	}

}

该实例的运行结果是：

throw和throws的区别：

1、作用不同：throws用于程序员自行产生并抛出异常；throws用于声明该方法内抛出了异常。

2、使用位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。

3、内容不同：throw抛出一个异常对象，且只能是一个；throws后面跟异常类，且可以跟多个异常类。

 

（5）自定义异常：

1、定义异常类，并继承Exception或者RuntimeException。

2、编写异常类的构造方法，并继承父类的实现。

常见构造方法：

public class MyException extends Exception {

	//构造方法1
	public MyException() {
		super();
	}
	
	//构造方法2
	public MyException(String message) {
		super(message);
	}
	//构造方法3
	public MyException(String message, Throwable cause) {
		super(message, cause);
	}
	//构造方法4
	public MyException(Throwable cause) {
		super(cause);
	}

}

自定义异常实例：

public class MyExceptionTest extends Exception{

	//构造方法
	public MyExceptionTest(String message) {
		super(message);
	}

	public static void main(String[] args) {
		String sex = "ww";
		try {
			setSex(sex);
		} catch (MyExceptionTest e) {//捕获MyExceptionTest类异常
			System.out.println(e.getMessage());
		}
	}
	
//	声明抛出MyExceptionTest类异常
	public static void setSex(String sex) throws MyExceptionTest {
		if ("男".equals(sex))
			System.out.println("性别是男！");
		else if ("女".equals(sex))
			System.out.println("性别是女！");
		else
			throw new MyExceptionTest("性别必须是男或者女！");

	}
}

运行结果：