异常

  编译期异常自行处理即可；运行时异常向上抛出。
定义：在我们编写程序时难免会出现错误，Java中的异常机制为了提高程序的健壮性和容错性而存在。
Throwable：Throwable类是Java语言中所有错误或异常的超类。
其已实现接口：Serializable;直接子类：Error、Exception；
除了RuntimeException都是编译期的异常，编译期的异常我们必须处理，如果不处理就会编译失败。

 运行期异常

  定义：编译期没有异常，但在执行过程中产生的异常。

  自行解决(try…catch语句块)

  在try内语句若未发生异常，则不会进入catch，反之则进入catch。
若try中语句发生异常，则不会执行异常语句后的代码。
如果异常通过catch得到处理，catch{}后面的代码与调用端的代码继续执行。
运行时发生异常的语句将不会在向下执行。

try{可能发生异常的语句;
}catch(异常类型 异常变量名){处理异常的代码;
}打印异常信息(需要配合输出语句使用)
异常变量名.getMessage();打印异常
异常变量名.printStackTrance();打印出具体的异常类和异常信息(需要配合输出语句使用)
异常变量名.toString();

class Calculate{public int devide(int a,int b) {//使用try...catchtry {int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);} catch (Exception e) {//1.使用getMessage方法//System.out.println(e.getMessage());//2.使用printStackTrace方法//e.printStackTrace();//3.使用toString方法//System.out.println(e.toString());}	}
}public class ExceptionTest {public static void main(String[] args) {Calculate calculate = new Calculate();calculate.devide(4, 0);}
}运行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zeroat com.exception.Calculate.devide(ExceptionTest.java:7)at com.exception.ExceptionTest.main(ExceptionTest.java:17)
1.使用getMessage方法后/ by zero
2.使用printStackTrace方法后java.lang.ArithmeticException: / by zeroat com.exception.Calculate.devide(ExceptionTest.java:8)at com.exception.ExceptionTest.main(ExceptionTest.java:21)
3.使用toString方法后java.lang.ArithmeticException: / by zero

  向上抛出(不处理会自动向上抛)

  被调用的方法中发生了异常但未做处理，那么异常将被向上抛至调用的方法。
若调用方法不处理异常，那么调用语句后的代码将不会执行。
在处理时同样可以使用try...catch语句处理。

class Calculate{public void devide(int a,int b) {int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ExceptionTest {public static void main(String[] args) {Calculate calculate = new Calculate();try {calculate.devide(5,0);} catch (Exception e) {e.printStackTrace();System.out.println("请检查计算公式！");}}
}
运行结果：java.lang.ArithmeticException: / by zero请检查计算公式！at com.exception.Calculate.devide(ExceptionTest.java:5)at com.exception.ExceptionTest.main(ExceptionTest.java:15)

   try…catch…catch

  可在try中定义两个或多个可能发生异常的语句，并在try后定义相关异常类型及异常变量名的catch。
try中异常语句的顺序与catch语句块的顺序无关。

class Calculate{public void devide(int a,int b) {int arr[] = new int[10];//当打印数组第10位时，发生数组越界异常System.out.println(arr[9]);//被除数为0时，发生数学异常int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ExceptionTest {public static void main(String[] args) {Calculate calculate = new Calculate();try {calculate.devide(5,0); } catch (ArithmeticException e) {System.out.println("发生数学计算异常！");}catch (ArrayIndexOutOfBoundsException e) {System.out.println("发生数组越界异常！");}}
}运行结果：
0
发生数学计算异常！

   try…catch(instanceof比较)

  try中有两个或多个可能会发生异常的语句时，可在catch的参数列表中使用异常父类Exception并定义异常变量名，然后使用if语句与instanceof将异常变量与异常类进行比较。

try{异常语句;
}catch(Exception 异常变量名){if(异常变量名 instanceof 异常子类名){处理代码;}else{处理代码;}
}

class Calculate{public void devide(int a,int b) {int arr[] = new int[10];System.out.println(arr[9]);int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ExceptionTest {public static void main(String[] args) {Calculate calculate = new Calculate();try {calculate.devide(5,0); } catch (Exception e) {if(e instanceof ArithmeticException) {System.out.println("发生数学计算异常！");}else if(e instanceof ArrayIndexOutOfBoundsException) {System.out.println("发生数组越界异常！");}else {System.out.println("发生了其他异常！");}}}
}

  try…catch…finally

  不论当try中是否发生异常，finally中的代码都会被执行。主要用来释放资源。
return后的局部变量的值将被保存下来，即使在未遇到下一个return同样局部变量之前改变了该局部变量的值，return局部变量的值也不会发生改变。只有在改变了局部变量的值后再次return该局部变量其值才会被改变。

int i = 10;
//此时返回的值为10
return i;
//即使改变了该局部变量的值，但因为是在return后作出改变，所以返回值不会发生变化
i = 20;

int i = 10;
//此时返回的值为10
return i;
//将该局部变量的值改变为20
i = 20;
//此时返回值为20
return i;

try{代码;
}catch(Exception 异常变量名){代码;
}finally{代码;
}

class Calculate{public void devide(int a,int b) {int arr[] = new int[10];System.out.println(arr[9]);int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ExceptionTest {public static void main(String[] args) {Calculate calculate = new Calculate();try {calculate.devide(5,0); } catch (Exception e) {if(e instanceof ArithmeticException) {System.out.println("发生数学计算异常！");}else if(e instanceof ArrayIndexOutOfBoundsException) {System.out.println("发生数组越界异常！");}else {System.out.println("发生了其他异常！");}}finally {System.out.println("无论何时都会执行的代码被执行！");}}
}输出结果：
0
发生数学计算异常！
无论何时都会执行的代码被执行！

  throw/throws关键字

  如果一个方法没有捕获到一个运行期异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

class Calculate{public void devide(int a,int b){int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ThrowException {
//这里使用了throws关键字public static void main(String[] args) throws Exception{Calculate calculate = new Calculate();calculate.devide(4, 0);}
}运行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zeroat com.exception.Calculate.devide(ThrowException.java:5)at com.exception.ThrowException.main(ThrowException.java:14)

class Calculate{public void devide(int a,int b) throws Exception{//这里使用if判断被除数是否为0if(b == 0) {throw new ArithmeticException();}int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ThrowException {public static void main(String[] args){Calculate calculate = new Calculate();try {calculate.devide(4, 0);} catch (Exception e) {e.printStackTrace();}}
}运行结果：
java.lang.ArithmeticExceptionat com.exception.Calculate.devide(ThrowException.java:6)at com.exception.ThrowException.main(ThrowException.java:19)

  一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

class Calculate{
//这里抛出了两个异常public void devide(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{int arr[] = new int[10];System.out.println(arr[10]);int result = a/b;System.out.println(a+"除"+b+"的结果为："+result);}
}public class ThrowException {public static void main(String[] args){Calculate calculate = new Calculate();try {calculate.devide(4, 0);} catch (Exception e) {e.printStackTrace();}}
}

 编译期异常

  try…catch自己处理

  向上层抛出，直至有代码进行处理

 自定义异常(运行期异常)

  步骤：
①定义一个异常类
②继承RuntimeException类
③继承父类的构造器
使用：如果发生异常，throw new 自定义的异常类名(输出信息);
继承父类构造器快捷方式：Source→General Constructions from SuperClass

public class StockException extends RuntimeException {public StockException() {super();// TODO Auto-generated constructor stub}public StockException(String message, Throwable cause) {super(message, cause);// TODO Auto-generated constructor stub}public StockException(String message) {super(message);// TODO Auto-generated constructor stub}public StockException(Throwable cause) {super(cause);// TODO Auto-generated constructor stub}
}

  新建一个类

public class ExceptionTest {public static void main(String[] args) {toBuy();}public static void toBuy() {int kucun = 0;if(kucun == 0) {throw new StockException("库存不足！");}}
}输出结果:
Exception in thread "main" com.exception.StockException: 库存不足！at com.exception.ExceptionTest.Tobuy(ExceptionTest.java:15)at com.exception.ExceptionTest.main(ExceptionTest.java:10)

 错误(Error)

  Error是Throwable的子类，标明程序出现了严重的问题，此问题程序无法解决。
错误都是以Error为结尾。