编译过程和运行过程中的错误和异常，Java提供异常处理机制，提高程序的健壮性。Java中，通过Throwable及其子类描述各种不同的异常类型
Throwable→Error(JVM错误) + Exception(RuntimeException+检查异常)
Exception：程序本身可以处理的异常
Unchecked Exception：编译器不要求强制处置的异常，包括RuntimeException类及其子类异常
Checked Exception(检查型异常)：编译器要求必须处置的异常，是除RuntimeException及其子类以外的其他Exception类的子类，如IOExcetipn + SQLException。编译器会检查这些异常，当程序中可能出现这类异常时，要求必须进行异常处理，否则编译不会通过。
Java异常处理机制：抛出+捕获
TryDemoOne.java
package com.imooc.test;
import java.util.InputMismatchException;
import java.util.Scanner;
public class TryDemoOne {
public static void main(String[] args) {
/* //要求:定义两个整数，输出两数之商
int one=12;
int two=2;
System.out.println("one和two的商是:" + (one/two));
*/
Scanner input=new Scanner(System.in);
System.out.println("=====运算开始=====");
try{
System.out.println("请输入第一个整数:");
int one=input.nextInt();
System.out.println("请输入第二个整数:");
int two=input.nextInt();
double res = (one/two);
System.out.println("one和two的商是:" + res);
}catch(ArithmeticException e) {
System.exit(1);//终止程序运行
System.out.println("除数不能为0！");
e.printStackTrace();
}catch(InputMismatchException e){
System.out.println("请输入整数！");
e.printStackTrace();
}catch(Exception e) {
System.out.println("程序错误！");
e.printStackTrace();
}
finally{
System.out.println("=====运算结束=====");
}
}
}
TryDemoTwo.java
package com.imooc.test;
import java.util.Scanner;
public class TryDemoTwo {
public static void main(String[] args) {
int res=test();
System.out.println("one和two的商是:" + res);
}
public static int test(){
Scanner input=new Scanner(System.in);
System.out.println("=====运算开始=====");
try{
System.out.println("请输入第一个整数:");
int one=input.nextInt();
System.out.println("请输入第二个整数:");
int two=input.nextInt();
return one/two;
}catch(ArithmeticException e) {
//System.exit(1);//终止程序运行
System.out.println("除数不能为0！");
return 0;
} finally {
System.out.println("=====运算结束=====");
//这里的return必须去掉，否则程序逻辑就会错误，返回的永远都是 100
//return 100;
}
}
}
有两种方式：自己抛自己处理，和自己抛让调用的方法处理
这里其实使用抛出异常来完成一些程序的业务逻辑，比如下面的例子就是 酒店的入住人员的年龄限制的代码
package com.imooc.test;
import java.util.Scanner;
public class TryDemoFour {
public static void main(String[] args) {
testAge();
}
public static void testAge(){
try{
System.out.println("请输入年龄:");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if( age < 18 || age > 80) {
throw new Exception("年龄小于18或大于80不得入住，需要适龄人员陪同");
} else {
System.out.println("欢迎入住本酒店");
}
}catch(Exception e){
e.printStackTrace();
}
}
}
package com.imooc.test;
import java.util.Scanner;
public class TryDemoFour {
public static void main(String[] args) {
try{
testAge();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void testAge() throws Exception{ // Exception可以替换为 Throwable
System.out.println("请输入年龄:");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if( age < 18 || age > 80) {
throw new Exception("年龄小于18或大于80不得入住，需要适龄人员陪同");
} else {
System.out.println("欢迎入住本酒店");
}
}
}
例如在上例中，可以这么新建一个类 HotelAgeException.java 继承 Exception：
// HotelAgeException.java
package com.imooc.test;
public class HotelAgeException extends Exception{
public HotelAgeException(){
super("年龄小于18或大于80不得入住，需要适龄人员陪同");
}
}
那么 TryDemoFour.java就需要修改一下：
package com.imooc.test;
import java.util.Scanner;
public class TryDemoFour {
public static void main(String[] args) {
try{
testAge();
} catch (HotelAgeException e) {
System.out.println(e.getMessage());
System.out.println("酒店前台工作人员不允许办理入住登记");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void testAge() throws HotelAgeException{ // Exception可以替换为 Throwable
System.out.println("请输入年龄:");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if( age < 18 || age > 80) {
throw new HotelAgeException();
} else {
System.out.println("欢迎入住本酒店");
}
}
}
在下面的例子中，testOne 抛出一个异常，testTwo接受并抛出另一个异常，testThree接受并抛出另一个异常
package com.imooc.test;
public class TryDemoFive {
public static void main(String[] args) {
try{
testThree();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void testOne() throws HotelAgeException {
throw new HotelAgeException();
}
public static void testTwo() throws Exception {
try{
testOne();
} catch(HotelAgeException e) {
throw new Exception("我是新产生的异常1" ,e);// 方法1
}
}
public static void testThree() throws Exception {
try{
testTwo();
} catch(Exception e) {
Exception e1=new Exception("我是新产生的异常2"); //方法2
e1.initCause(e);
throw e1;
//throw new Exception("我是新产生的异常2" ,e);
}
}
}
上述代码避免了一般的异常链导致的只获取最后 testThree("我是新产生的异常2") 的弊端，对于每一个异常的信息都保存并显示出来，有两种方法
如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出；
如果一个方法中可能出现可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误；
当抛出了异常，则该方法的调用者必须处理或者重新抛出该异常；
当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所声明异常的同类或子类。
针对这个有代码证明：
// FatherTest.java
package com.imooc.test;
public class FatherTest {
public void test() throws HotelAgeException{
throw new HotelAgeException();
}
}
//HotelAgeException.java
package com.imooc.test;
public class HotelAgeException extends Exception {
public HotelAgeException(){
super("18岁以下，80岁以上的住客必须由亲友陪同");
}
}
class SubException extends HotelAgeException{}
//SubTest.java
//在这里 子类抛出的SubException继承自父类抛出的HotelAgeException,否则就会报错
package com.imooc.test;
public class SubTest extends FatherTest {
@Override
public void test() throws SubException {
// TODO Auto-generated method stub
//super.test();
}
}
处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
在多重catch块后面，可以加一个catch（Exception e）来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加finally语句块去释放占用的资源
原文：https://www.cnblogs.com/it-bt/p/14854472.html