异常

一、异常【理解】
① 概念：程序运行过程中出现的一些不正常的情况。
② 异常的处理的必要性：减少用户不必要的损失。
二、异常的分类【面试重点】
1. 所有的异常的父类是Throwable类，位于java.lang
常用的方法：
① String getMessage():获取String类型的异常信息。
② void printStackTrace():获取方法调用栈中，异常详细的信息。
2. Throwable具有两个直接的子类：
① Error:表示仅靠程序本身无法恢复的严重错误，例如：内存不足，或是方法调用栈溢出      

  特点：在大多数的情况下，遇到这样的错误，程序无法处理。

eg：

package test_exception;
public class TestError {
public static void main(String[] args) {
test();
}
public static void test(){
System.out.println("~~~~~~~~~~");
test();
}
}

② Exception:分类两类
a. RuntimeException:称为运行时异常、未检查异常(RuntimeException+其所有的子类)
特点：编译器编译时不会检测它，运行时报错。
     这类异常可以避免，可以处理也可以不处理。

常见的运行时异常：
I.  数组下标越界：java.lang.ArrayIndexOutOfBoundsException
II. 类型转换异常：java.lang.ClassCastException
III. 空指针异常：java.lang.NullPointerException【常见中常见】
IV. 数字格式转换异常：java.lang.NumberFormatException

b. 非RuntimeException：非运行时异常、已检查异常(和RuntimeException异常没有继承关系的类)
特点：编译器编译时检测它，出现这类异常，编译不通过，必须处理。

eg：

package test_exception;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

public class TestException4 {
public static void main(String[] args){
System.out.println("main start---------");
m1(5);
System.out.println("main end---------");
}
public static void m1(int n){
System.out.println("m1----start-----");
try {
m2(n);
} catch (SQLException e) {
System.out.println("SQLException已经被处理...");
}
System.out.println("m1----end-------");
}
public static void m2(int n)throws SQLException{
System.out.println("m2-----start-----");
try{
if(n==1) throw new RuntimeException();
if(n==2) throw new ClassNotFoundException();//非运行时异常
if(n==3) throw new FileNotFoundException();
if(n==4) throw new EOFException();
if(n==5) throw new SQLException();
System.out.println("~~~~~~~~~~~~~end~~~~~~~~~~~~");
}catch(ClassNotFoundException e){
System.out.println("ClassNotFoundException已经处理...");
}catch(IOException e){
System.out.println("IOException异常已经被处理...");
}
System.out.println("m2-----end-----");
}
}

三、异常的产生
1. 自动产生异常：【理解】
程序在运行过程中，遇到出错的代码，则自动产生异常，程序自动终止。
2. 手动产生异常【开发重点】
① 语法： throw new 异常类名(实参); 
② 位置：手动产生异常，必须定义在方法内部。
③ 结果：相当于return语句，导致程序的终止。


四、异常的传递：【理解】
沿着方法的调用链反向进行传递，最终传递给JVM，导致程序终止。

五、异常的处理：【开发应用重点】
1. 消极处理异常
① 关键字： throws ，声明异常，定义在方法的声明后面。
② 语法：修饰符 返回值类型 方法名(形参列表)throws 异常类名{}
③ 作用：采用消极处理异常的方式只是将异常传递，推卸责任，程序仍然会被终止。
         但是可以让非运行时异常在编译时通过。
2. 积极处理异常
① 语法：
try{
//可能出现的异常的语句
}catch(异常类名 e){ //将捕获到的异常，自动赋值给e引用
//一旦出现异常，执行的语句
}
② 注意：
a. try 后面可以跟多个 catch,try一旦出现异常，从第一个catch依次
   往下匹配，直到匹配成功。
b. catch中可以利用多态，通过父类型处理异常，可以处理的异常类型：
   本类型+所有的子类的异常。
   但是：父类型的catch必须定义在其子类型catch的后面。
c. catch中只能处理try中可能出现的非运行时异常。
       catch中可以处理任意的运行时异常，即使在try中没有出现的可能性。【了解】
d. 积极处理异常的同时可以声明抛出异常。
        e. finally中的语句是必须执行的语句：
语法：
try{
//....
}catch(异常类名 e){
//...
}finally{
//不管有没有异常，必须执行的语句
}
            注意：finally中一般不放return语句。
      finally一般用于释放资源。
    区分：final 、finalize、 finally？？？【面试题目】
      final是修饰符：可以修饰变量、方法、类
       final修饰的变量是作用范围内常量
   final修饰的方法可以被继承，不能被覆盖
   final修饰的类不能被继承，即没有子类。
  finalize是方法的名字：垃圾回收器回收垃圾对象时，调用的方法
  finally是 try..catch...finally结构，finally中的语句不管异常一定被执行；

             finally一般用于释放资源。

eg：

import java.util.Scanner;
public class TestFinally {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入两个整数：");
int n=sc.nextInt();
int m=sc.nextInt();
System.out.println("结果："+div(n,m));
}
public static int div(int n,int m){
try{
System.out.println("----try------");
return n/m;
}catch(Exception e){
System.out.println("分母不能为0!!!!");
return 0;
}finally{
System.out.println("----finally-----");
// return -1;
}
}
}
六、自定义异常类
1. 类继承Exception或是其子类；如果自定的异常类想成为运行时异常，
   它需要继承RuntimeException或是RuntimeException的子类。
   自定义异常类通常定义为：运行时异常。
2. 提供两个构造方法：
一个构造方法为无参数的构造方法；
另一个构造方法为带有String类型参数的构造方法：
利用super(message),message描述异常的String信息。

七、方法的覆盖(终结版)【重点】
1. 子类的方法名、参数列表、返回值类型必须和父类相同
    2. 子类的访问修饰符必须和父类相同或是更宽
    3. 子类不能抛出比父类更多、更宽的异常