黑马程序员——Java之异常处理

——–Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

1： 异常：就是程序在运行时（非编译时）出现的不正常现象
* 异常的由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象，其实就是Java对不正常情况进行描述后的对象体现
* 对问题的划分：两种：一种是严重的问题（Error），另一种是非严重的问题（Exception）
* 对于严重的问题，Java通过Error类进行描述（对于Error一般不编写针对性的代码对其进行处理）
* 对于非严重的问题，Java通过Exception类进行描述（对于Exception可以使用针对性的处理方式进行处理）
* 但是：无论是Error还是Exception都具有一些共性内容（比如：不正常情况的信息，引发原因等），因此可以将Error类和Exception类进行向上抽取形成（Throwable类）
* Throwable类的子类：
* （1）Error类
* （2）Exception类
* 2：异常的处理
* java 提供了特有的语句进行异常的处理，如：
* try{
* 有异常的java语句
* }catch(Exception e){
* 异常处理语句
* }finally{//通常用于关闭资源
* 一定要执行的语句
* }
*
* 3：对捕获到的异常对象e进行的常见方法操作
* String getMessage();获取异常的信息
* String toString();获取异常信息和异常名称
* void printStackTrace();获取异常出现的位置和异常信息和异常名称，实际上JVM默认的异常处理机制就是在调用printStackTrace()方法，打印异常跟踪信息
* 4：异常处理实例

class AException{
 *   public double func(int a,int b){
 *       return a/b;
 *   }
 *}
 *
 *public class YiChang {
 *
 *  public static void main(String[] args) {
 *      AException ax=new AException();
 *      try{
 *          double result=ax.func(2, 0);//把异常抛给catch
 *          System.out.println(result);
 *      }catch(ArithmeticException e){//抓住该异常并进行处理
 *          System.out.println(e.toString());
 *      }
 *      System.out.println("over");
 *  }
 *}

• 5：多异常处理
• （1）声明异常时，建议声明更为具体的异常，这样处理可以更为具体
• （2）对方声明几个异常，就对应几个catch块，不要定义多余的catch块
• （3）如果多个catch块中的异常出现了继承关系，父类异常块放在最下面
• 建议在进行catch处理时，catch中一定要定义具体的处理方式，不要简单的定义一条e.printStackTrace();语句，也不要简单的书写一条输出语句
• 6：自定义异常（因为自己在开发时，项目中会出现特有的问题，而这些问题并未被Java所描述并封装成对象）
• 自定异常必须继承Exception类
• 因为：
• 异常体系有一个特点：因为异常类和异常对象都被抛出，它们都具有可抛性，这个可抛性是Throwable这个体系中独有的（从类名中也可以看出），只有这个体系中的类和对象才可以被throws和throw操作
• 当在函数内部出现了throw抛出异常对象，那么就必须给出对应的处理动作（要么throws给函数的调用者，要么try-catch）
• 一般情况下，在函数内部出现异常，函数上需要声明（格式：throws 异常类名）
• 如何在自定义异常类中，定义异常信息？
• 因为父类中已经把异常信息的操作都已经完成了，所以子类只要在构造时，将异常信息传递给父类，通过super()语句，那么就可以直接通过getMessage()方法获取自定义的异常信息了
• 7：自定义异常类的抓抛模型实例

 class FuShuException extends Exception{
*       public FuShuException(){
*           
*       }
*        public FuShuException(String mes){
*           super(mes);
*        }
*
*    public double func(int a,int b) throws FuShuException{
*        if(b<0)
*            throw new FuShuException("除数为负数了");
*        return a/b;
*    }
*}
*
*public class YiChang {
*
*   public static void main(String[] args) {
*       FuShuException ax=new FuShuException();
*       try{
*           double result=ax.func(2, -3);//把异常抛给catch
*           System.out.println(result);
*       }catch(FuShuException e1){//抓住该异常并进行处理
*           System.out.println(e1.toString());
*       }catch(ArithmeticException e2){
*           System.out.println(e2.toString());
*       }
*       System.out.println("over");
*   }
*}

*8：throws和throw的区别
* （1）throws使用在函数上，后面跟的是异常类名，可以跟多个异常类名，用逗号隔开
* （2）throw使用在函数内，后面跟的是异常对象
*9：对于异常分两种：
* （1）编译时被检测的异常（编译时异常），在自定义异常类时如果继承的是Exception类，就必须要在出现异常的函数后面声明自定义异常的类型，并且在调用时也需要声明
* （2）编译时不被检测的异常（及运行时异常，RuntimeException异常类及其子类）
*
*10：三种结合格式：

（1） try{
 *
 *}catch{
 *
 *}
 *  （2）try{
 *  
 *  }catch(){
 *  
 *  }finally{
 *  
 *  }
 *   （3）try{
 *   
 *   }finally{
 *   
 *   }

*记住一点：catch里面是写处理异常的语句，如果没有catch就表示try抓住的异常没有被处理过，如果该异常是编译时异常，就必须在函数外部声明出去
*
*11：异常在子父类方法重写时的体现
* （1）子类在重写父类方法时，如果父类的方法抛出了异常，那么子类的重写方法要么不抛异常（自己处理），要么只能抛出父类的异常或父类异常的子类异常
* （2）如果父类方法抛出了多个异常，那么子类在重写该方法时，只能抛出父类异常的子类异常
* （3）如果父类或者接口的方法中没有异常抛出，那么子类在重写该方法时，也不可以抛出异常，如果子类的方法中真出现了异常，那么就只能在子类的方法中使用try-catch语句进行处理，绝对不能抛
*总结：异常是什么呢？
* 异常是对问题的描述，将问题进行对象的封装
*异常体系：
* Throwable
* —Error
* —Exception
* —RuntimeException
*
*异常有两种：
* 编译时异常：程序在编译时就会检测的异常，该异常在编译时，如果没有处理（throw 或try），编译会失败，该异常若被标识，代表这是可以处理的异常
* 运行时异常：
*注意：
* （1）finally中定义的通常是关闭资源的代码，因为资源必须要释放
* （2）finally只有一种情况不会执行，当执行到System.exit(0)时，JVM结束，finally语句执行不到
*
*异常的好处：
* （1）将问题进行封装，便于对问题进行描述和处理
* （2）将正常流程代码与问题处理代码相分离，方便阅读和修改