异常是指程序运行时可能出现的一些错误，比如试图打开一个根本不存在的文件等。异常处理会改变程序的运行流程，给程序处理的机会错误;
1、Java使用 throw 关键字抛出异常类（）或者异常类的子类的实例，表示异常的发生；
2、异常对象可以调用以下方法来获取或输出异常的信息；
public String getMessage();
public void printStackTrace();
public String toString();3、Java使用try{ }catch(){ }语句来处理异常；
try{ }catch(){ } 语句：
1、将可能引发异常的操作放在try{}部分；
2、一旦try{}部分抛出异常对象或者调用可能抛出异常对象的方法，try{}部分会立即停止执行，转向对应的catch部分；
3、程序将异常发生后的处理放在catch(){}部分；
try{ }catch(){ } 语句格式如下：
try{
...
}catch(Exception e){
...
}
或者
try{
...
}catch(ExceptionSubClass1 e){
...
}catch(ExceptionSubClass2 e){
...
} 和 分别是继承该类的子类，即自定义异常类；
异常类和 try{ }catch(){ } 语句的使用：
通过 try{} 部分发生异常操作，通过关键字 throw 抛出一个实例，并发送到语句 catch(e){ } 中的异常类对象 e，以及 catch(e){ } 的 { } 部分决定是否打印异常信息并进行处理；
以下代码↗：
public class customizeExceptionTest {
void method(int x,int y) throws Exception{
int sum = x + y ;
if(sum > 100 ){
throw new Exception("错误，x+y>100");
}else{
System.out.println("x+y的值 = "+sum);
}
}
public static void main(String [] args){
customizeExceptionTest cet = new customizeExceptionTest();
try{
cet.method(11, 11);
cet.method(10, 10);
cet.method(100, 1);
cet.method(1, 1);
}catch(Exception e){
System.out.println("打印异常信息："+e.getMessage());
}
}
}
代码中，try{}部分执行到cet.(100.1);时，会发生异常，通过关键字throw抛出异常
异常实例(“错误，x+y>100”); 并进入catch(){ }部分处理异常；
当try{}中发生异常时，该异常下面的语句将不再被执行，如cet.(1, 1); 代码中的语句不会被执行；
代码输出结果：
x+y 的值 = 22
x+y 的值 = 20
打印异常信息：error,x+y>100
自定义异常类的定义：
自定义异常类是异常类（class）的子类，可以根据程序的需要指定哪些方法生成哪些异常；
1、使用自定义异常类时，需要另外一个Java关键字；
2、关键字可以声明一个方法中发生的几种异常，并在方法的方法体中指定产生异常的操作；
产生异常的操作是指： throw new("异常信息"); //执行完这条语句后，会跳转到catch(){ }部分；
3、即：创建对应异常类的对象，并使用 throw 关键字抛出异常的实例，导致方法结束执行；
自定义异常类的使用：
创建一个类，继承该类，并在类中创建异常处理方法；
以下代码↗：
//自定义异常类，继承Exception
public class customizeExceptionClass extends Exception {
String message;
//接收异常信息
public customizeExceptionClass(String string) {
message = string ;
}
//输出异常信息
public String getMessage(){
return message;
}
}import java.util.Scanner;
//测试类
public class customizeException {
public static void main(String[] args) {
//从键盘输入一个数，判断这个数是否>100,是则抛出异常
System.out.println("请输入一个数字，并按enter键结束输入：");
Scanner sc = new Scanner(System.in);
try{
double number = sc.nextDouble();
for(int i=3;i>0;i--){
System.out.println("输入正确，输入次数还剩余："+i+" 次");
number = sc.nextDouble();
//通过if语句，判断这个数是否>100,是则抛出异常
if(number > 100){
throw new customizeExceptionClass("输入数值大于100");
}
}
}catch(customizeExceptionClass e){
System.out.println("异常处理，错误："+e.getMessage());
}
//try{}catch(){} 语句结束
}
}
代码中自定义了一个异常类ass。 当该异常类运行的try{}部分发生异常时，catch(){ }部分调用异常信息；
代码输出结果：
请输入数字并按回车键结束输入：
12
输入正确，剩余输入次数：3次
14
输入正确，剩余输入次数：2次
155
异常处理，错误：输入值大于100
try{ }catch(){ } 语句和 throw 关键字的执行流程：
上面的代码中，首先执行的是try{}部分的操作。 当输入155时，条件>100成立，抛出new ass("输入值大于100");
抛出异常实例和异常信息，然后跳转到catch(){ }部分，通过()中的自定义异常类对象e接收异常实例和异常信息，
最后{ }部分打印异常信息e.();
关键字用法：
关键字可以声明一个方法中发生的几种异常，并在方法的方法体中指定产生异常的操作；
以下代码↗：
//自定义异常类
public class customizeExceptionClass extends Exception {
String message;
//获取异常信息
public customizeExceptionClass(String string) {
message = string ;
}
//输出异常信息
public String getMessage(){
return message;
}
}//创建可能发生异常的方法 method ，调用 throws 关键字表明产生的若干个异常
public class customizeExceptionTest {
//throws的使用
void method(int x,int y) throws customizeExceptionClass,Exception{
int sum = x + y ;
if(sum > 100 ){
throw new customizeExceptionClass("错误，x+y>100");
}else if(sum < 0){
throw new Exception("错误，x+y<100");
}else{
System.out.println("正确，x+y的值 = "+sum);
}
}
}
//测试类，throws的使用
public class customizeException {
public static void main(String[] args) {
//throws的使用
customizeExceptionTest cet = new customizeExceptionTest();
try{
cet.method(11, 11);
cet.method(10, 10);
cet.method(100,-111);
cet.method(1, 1);
}catch(customizeExceptionClass e){
System.out.println("customizeExceptionClass打印异常信息："+e.getMessage());
}catch(Exception e){
System.out.println("Exception打印异常信息："+e.getMessage());
}
}
}
在上面的代码中，方法(int x, int y)使用关键字来指示两种可能的异常。 当操作的try{}部分出现异常情况时，会抛出异常，并转到该异常对应的catch处。 （）{} 陈述;
代码输出结果：
正确，x+y 的值 = 22
正确，x+y 的值 = 20
打印异常信息：error,x+y
当代码为cet.(100,-111); 改为cet.(100,111);，出现ass类异常，输出为：
正确，x+y 的值 = 22
正确，x+y 的值 = 20
ass打印异常信息：error,x+y>100
