Java异常和异常处理

Java异常分类

• 异常：程序不正常的行为或者状态
• 异常处理：程序返回到安全状态，且允许用户保存结果，并以适当的方式关闭程序
• 异常分类：

第一种分类

• Throwable(可丢弃的)：所有错误的祖先
• Error:系统内部错误或资源耗尽。不管
• Exception：程序有关的异常。重点关注
  • RuntimeException：程序自身的错误（除零、空指针、数组越界等等）
  • 非RuntimeException：外界相关的错误（打开一个不存在的文件、加载一个不存在的类等等）

第二种分类

• Unchecked Exception(编译器不会辅助检查的，需要程序员自己管的)异常，包括Error子类和RuntimeException子类。
• 非RuntimeException的Exception的子类：（编译器会辅助检查的）异常，又叫做Checked Exception

异常处理

• 用户可以及时保存结果
• 可以抓住异常，分析异常内容
• 控制程序返回到安全状态

try-catch-finally

• 一种保护代码正常运行的机制
• try必须有，catch和finally至少要有一个
• try:正常业务逻辑代码（程序需要实现的功能）
• catch：当try发生异常，将执行catch代码。
• finally：当try或catch执行结束后，必须执行finally！
• 当catch内部再次发生异常，也不影响finally的正常运行，因为finally最后肯定会执行的
• catch块可以有多个！每个有不同的入口形参！发生的异常必须和形参匹配才能进入，否则会进入finally块
• 由于catch块的异常匹配是从上到下，所以一般将小的异常（ArithmeticException算数异常）写在前面，大的宽泛的异常（Exception）写在后面

小异常写前面，大异常写后面：

public class MultipleCatchDemo {
    public static void main(String[] args) {
        try {
            int a = 5/0;//异常
        }catch (Exception ex){//由于Exception是所有异常的祖先，所以一定会进入
            ex.printStackTrace();
        }catch (ArithmeticException e){//ArithmeticException是Exception的子类 一定不会进入，报错，必须把小异常写在前面
            e.printStackTrace();
        }finally {
            System.out.println("over");
        }
    }
}

• try-catch-finally是允许包含的，内部都可以继续写一个完整的try-catch-finally结构

throws声明异常

• 方法存在可能异常的语句，但不处理，那么可以使用throws来声明
• 调用有throws异常（checked exception）的方法，要么处理这些异常，要么再次向外throws，直到main函数来处理为止，或者main函数也不处理，始终throws？？？？？

public class ThrowsDemo {
	//如果在main中不使用try处理，则需要：
	//public static void main(String[] args) throws ArithmeticException{...}
    public static void main(String[] args) {
        //如果在main函数中调用了这种方法，就需要用try处理这个（未处理的）异常
        try{
            int result = new Test().divide(3,1);
            System.out.println("the 1st result is"+result);
        }catch (ArithmeticException ex){
            ex.printStackTrace();
        }

        //这里调用时没有处理这个throws了的算数异常，就会报错
        int result = new Test().divide(3,0);
        System.out.println("the 2st result is"+result);
    }
}
class Test{
    public int divide(int x,int y)throws ArithmeticException{//方法可能存在异常，如果自己无法处理，必须抛出异常，这里表示可能的异常为算数异常
        int result = x/y;
        return result;
    }
}

• 与继承相关：子类重写父类的方法时，如果该父类有抛出的异常，则子类抛出的异常不可以比父类大（小于或等于父类）
  实例：
  父类：

  public class Father{
  	public void f1()throws ArithmeticException{}
  }
  

  子类：

  public class Son extends Father{
  	public void f1()throws ArithmeticException{}//这里不可以写Exception，子类重写的方法所声明的异常不能超出父类规定的范围
  }
  

自定义异常

• Exception类是所有异常的父类

• 自定义异常需要继承Exception类或其子类

  • 继承自Exception，就变成Checked Exception，编译器会检查，会报错
  • 继承自RuntimeException，就变成Unchecked Exception，编译器不会检查，不会报错

• 自定义重点在构造函数

  • 调用父类Exception的message构造函数,声明错误信息
  • 可以自己定义自己的成员变量

• 在程序中采用throw主动抛出异常

采用throw主动抛出异常实例：

public class MyExceptionTest {
    public static void testException()throws MyException{
        //在方法内部程序中，抛出异常采用throw；在方法头部声明中，采用声明异常采用throws
        throw new MyException("10001","the reason of myException");//程序主动抛出异常，运行构造函数中的super()会直接输出异常
    }

    public static void main(String[] args){
        //MyExceptionTest.testException();
        try {
            MyExceptionTest.testException();
        }catch (MyException ex){
            ex.printStackTrace();
            System.out.println("returnCode:"+ex.getReturnCode());//returnCode:10001
            System.out.println("returnMsg:"+ex.getReturnMsg());//returnMsg:the reason of myException
        }
    }
}