7 Java基础 异常

异常：是对问题的描述，将问题进行对象的封装

====================

异常体系

Throwable

    |--Error

          |--Exception

               |---RuntimeException

-=========================================

异常体系的特点：异常体系中所有类以及建立的对象都具备可抛性

                                     也就是说可以被throw和throws关键字所操作

                                     只有异常体系具备这个特点

============================================

 

throw 和throws的用法

throw定义在函数内，用于抛出异常对象

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开

 

当函数内容有throw抛出异常对象并未进行try处理必须要在函数上声明，否则编译失败

注意 RuntimelException除外也就是说 函数内如果抛出的是RuntimelException异常 函数上可以不用声明

如果函数声明了异常调用者需要进行处理处理方法可throws可try

===========================================================

异常有两种：编译时被检测异常

                                     该异常在编译时如果没有处理（没有throws也没有try）编译失败

                                     该异常被标识 代表着可以被处理

                           

                            运行时异常（编译时不检测）

                                     在编译时 不需要处理 编译器不检查

                                     该异常的发生 建议不处理 让程序停止 需要对代码进行修正

==============================================

异常处理语句

try

{

         需要被检测的代码

}

catch ()

{

         处理异常的代码

}

finally

{

         一定会执行的代码

}

         ========================================

         第一个格式

try

{

 

}

catch()

{

 

}

第二种格式

try

{

 

}

catch()

{

 

}

finally

{

 

}

第三种格式

try

{

 

}

finally

{

 

}

======================================================

 

注意：

1 finally中定义的通常是关闭资源代码 因为资源必须释放

2 finally只有一种情况不会执行 当执行到System,exit(0);

finally 不会执行

=================================================

自定义异常：

                   定义类继承Exception或者RuntimelException

                   1为了让该自定义类具备可抛性

                   2让该类具备操作异常的共性方法

 

                   当要定义自定义异常的信息时 可以使用父类已经定义好的功能

                   异常信息传递给父类的构造函数

 

                   classMyException extends Exception

                   {

                            MyException(Stringmessage)

                            {

                                     super(message);

                            }

                   }

 

自定义异常：按照Java的面向对象思想将程序中出现的特有问题进行封装

 

 

========================================================

 

异常的好处：

 

1将问题进行封装

2将正常流程代码和问题处理代码相分离 方便于阅读

 

 

异常的处理原则：

 

   1处理方式有两种：try或者throws

   2调用到抛出异常的功能时 抛出几个 就处理几个

   一个try对应多个catch

   3多个catch 父类的catch放最下面

  4catch内需要定义针对性的处理方式不要简单的定义printStackTrace输出语句。

   也不要不写

   当捕获到的异常 本功能处理不了时 可以继续在catch中抛出

  try

   {

                   thrownew AException();

   }

  catch ()

   {

 

            throw e;

   }

         如果该异常处理不了 但并不属于该功能出现的异常

         可以将异常转换后 再抛出和该功能相关的异常

 

         或者异常可以处理 但需要将异常产生后和本功能相关的问题提供出去

         让调用者知道 并处理 也可以将捕获异常处理后 转换新的异常

 

 

try

{

         thrownew AException();

}

catch (AException e)

{

         //AException处理

         thrownew BException();

}

 

比如，汇款的例子

 

 

异常的注意事项：

         在子父类覆盖时：

         1子类抛出的异常必须是父类的异常的子类或者子集

         2如果父类或者接口没有异常抛出时 子类覆盖出现异常 只能try 不能抛

 

  /*

异常：就是在程序运行时出现不正常情况

异常由来：问题也是现实生活中一个具体的事物也可以通过Java的类的形式进行描述并封装成对象

  其实就是Java对不正常情况进行描述后的对象体现

 

  对于问题的划分：分为两种 一种是严重的问题 一种是非严重的问题

 

  对于严重的 Java通过Error类进行描述

  对于error 一般不编写针对性的代码对其进行处理

 

  对于非严重的 Java通过Exception类进行描述

  对于exception可以使用针对性的处理方式进行处理

无论error或者exception都具有一些共性内容

比如：不正常情况的信息、引发原因等

Throwable|--error

        |--exception

2 异常的处理

 

Java提供了特有的语句进行处理。

try

{

         需要被检测的代码

}

catch（异常类 变量）

{

         处理异常的代码（处理方式）

}

finally

{

        

         一定会执行的语句

}

3对捕获到的异常对象进行常见方法操作

String getMssage():获取异常信息。

 

对多异常的处理

1声明异常时 建议声明更为具体的异常 这样处理的可以更具体

2对方声明几个异常 就对应有几个catch块 不要定义多余的catch块

 如果多个catch块中的异常出现继承关系 父类异常catch块放最下面

 

 

建议在进行catch处理时 catch中一定要定义具体处理方式

不要简单一条 e.printStackTrace（）

也不要简单的就书写一条输出语句

 

 

*/

 

class Demo

{

         intdiv(int a, int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现的问题

         {

                   returna/b;

         }

}

class Exceptiondemo

{

         publicstatic void main(String[] args)

         {

                   Demod =new Demo();

 

                   try

                   {

                            intx=d.div(4,0);

 

                            System.out.println("x="+x);

                   }

                   catch(Exception e)

                   {

                            System.out.println("处零啦");

                            System.out.println(e.getMessage());//打印异常信息

                            System.out.println(e.toString());//异常名称：异常信息

                            e.printStackTrace();//异常名称 异常信息 异常出现的位置

                                                                           //其实jvm默认的异常处理机制，就是在调用printStackTrace方法

                                                                           //打印异常的堆栈的跟踪信息

 

 

                   }

                  

                   System.out.println("over");

         }

}

 

class Demo

{

         intdiv(int a, int b)throws ArithmeticException, ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现的问题

         {

                   int[]arr=new int[a];

                   System.out.println(arr[4]);

                   returna/b;

         }

}

class Exceptiondemo1

{

         publicstatic void main(String[] args) //throws Exception

         {

                   Demod =new Demo();

 

                      try

                      {

                                     intx=d.div(4,0);

 

                            System.out.println("x="+x);

        

                      }

                      catch ( ArithmeticException e)

                      {

                              

                            System.out.println(e.toString());

                            System.out.println("被零除了");

                      }

                  

                      catch ( ArrayIndexOutOfBoundsException e)

                      {

                              

                            System.out.println(e.toString());

                            System.out.println("角标越界了");

                      }

                       catch ( Exception e)

                      {

                               

                            System.out.println(e.toString());

                           

                      }

                  

                  

                   System.out.println("over");

         }

}

 

/*

应为项目中会出现一些特有的问题

而这些问题并未被Java所描述并封装对象

所以对于这些特有的问题可以按照Java的对问题封装的思想

将特有的问题进行自定义的异常封装

 

自定义封装

需求：在本程序中对于除数是-1 也视为是错误的是无法进行运算的

那么就需要对这个问题进行自定义的描述

 

当在函数内部出现了throw抛出异常对象那么久必须要给出对应的处理动作

要么在内部try catch处理

要么在函数上声明让调用者处理

 

一般情况在函数内出现异常函数上需要声明

 

发现打印结果中只有异常的名称 却没有异常的信息

因为自定义的异常并未定义信息

 

如何定义异常信息呢？

因为父类中已经把异常信息的操作都完成了

所以子类只要在构造时将异常信息传递给父类通过super语句

那么就可以直接通过getMessage方法获取自定义异常信息

 

自定义异常：

必须是自定义类继承Exception

 

继承Exception原因：

 

异常体系有一个特点：因为异常类和异常对象都需要被抛出

他们都具备可抛性这个可抛性是throwable体系中的独有特点

只有这个体系中的类和对象才可以被throws和throw操作

 

 

throws和throw的区别

throws使用函数上（小括号和大括号之间）

throw使用在函数内

 

throws后面跟的异常类 可以跟多个用逗号隔开

throw后面跟的是异常对象

*/

 

class FushuException extends Exception//getMessage();

{

         privateint value;

         FushuException()

                   {

                   super();//隐示

                   }

         FushuException(Stringmsg,int value)

         {

                   super(msg);

                   this.value=value;

         }

         publicint getValue()

         {

                   returnvalue;

         }

}

class Demo

{

         intdiv(int a, int b) throws FushuException

         {

                   //手动建立对象并手动抛出

                   if(b<0)

                   {

                            thrownew FushuException("出现了除数出现负数的情况",b);//手动通过throw关键字抛出一个自定义异常对象

                   }

                   returna/b;

         }

}

class Exceptiondemo2

{

         publicstatic void main(String[] args)

         {

                       Demo d =new Demo();

                            try

                            {

                                     intx=d.div(4,-1);

 

                            System.out.println("x="+x);

                            }

                            catch(FushuException e)

                            {

                                      System.out.println(e.toString());

                                     //  System.out.println("除数出现负数了");

                                     System.out.println("错误的负数是"+e.getValue());

                            }

 

                                    

                       System.out.println("over");

         }

}

 

/*

Exception 中有一个特殊的子类异常RuntimeException运行时异常

如果在函数内抛出该异常函数上可以不用声明编译一样通过

如果在函数上声明了该异常调用者可以不用进行处理编译一样通过

 

之所以不用在函数上声明是因为不需要让调用者处理

当该异常发生希望异常停止 因为在运行时 出现了无法继续运算的情况

希望程序停止后程序员对代码进行修正

 

 

自定义异常时如果该异常的发生无法再继续进行运算

 

就让自定义异常继承RuntimeException

 

对于异常分两种:

1编译时被检测的异常

2编译时不被检测的异常（运行时异常RuntimeException以及其子类）

*/

class FushuException extendsRuntimeException

{

         FushuException(Stringmsg)

         {

                   super(msg);//传给父类

         }

}

class Demo

{

         intdiv(int a, int b) //throws ArithmeticException

         {

                   if(b<0)

                            thrownew FushuException("除数出现负数了");//面试

                   //手动抛

                   if(b==0)

                            thrownew ArithmeticException("被零除了");

                  

                   returna/b;

         }

}

class Exceptiondemo3

{

         publicstatic void main(String[] args)

         {

                       Demo d =new Demo();

                           

                                     intx=d.div(4,-3);

 

                            System.out.println("x="+x);

                                                       

                       System.out.println("over");

         }

}

/*

class Person

{

         publicvoid checkName(String name)

         {

                   //if(name.equals("lisi"))//NullPointException

                   if("lisi".equals(name))//if(name!=null&& name.equals)

                            System.out.println("YES");

                   else

                            System.out.println("no");

         }

}

 

main ()

{

         Personp=new Person();

         p.checkName(null);

}*/

 

 

/*

finally代码块：定义一定执行的代码

通常用于关闭资源

第一个格式

try

{

 

}

catch()

{

 

}

第二种格式

try

{

 

}

catch()

{

 

}

finally

{

 

}

第三种格式

try

{

 

}

finally

{

 

}

记住一点：catch是用于处理异常的如果，没有catch就代表异常没有被处理过，如果该异常是检测时异常

那么必须声明

*/

 

class Demo

{

         publicvoid method()

         {

                   try

                   {

                            thrownew Exception();

                   }

         /*     catch (Exception e)

                   {

                            try

                            {

                                     throwe;

                            }

                            catch()

                            {

                            }

                   }*/

                   finally

                   {

                            //关资源

                   }

                  

         }

}

 

 

class Exceptiondemo4

{

         publicstatic void main(String[] args)

         {

 

         }

 

}

 

/*class FushuException extends Exception//getMessage();

{

         FushuException(Stringmsg)

         {

                   super(msg);

                  

         }

        

}

 

 

class Demo

{

         intdiv(int a, int b) throws FushuException

         {

                   //手动建立对象并手动抛出

                   if(b<0)

                   {

                            thrownew FushuException("出现了除数出现负数的情况",b);//手动通过throw关键字抛出一个自定义异常对象

                   }

                   returna/b;

         }

}

 

 

class Exceptiondemo4

{

         publicstatic void main(String[] args)

         {

                       Demo d =new Demo();

                            try

                            {

                                     intx=d.div(4,-1);

 

                            System.out.println("x="+x);

                            }

                            catch(FushuException e)

                            {

                                      System.out.println(e.toString());

                                     return;

                            }

                            finally

                     {

                                      System.out.println("finally");//finally中存放的是一定会被执行的代码

                                    

                            }

 

                                    

                       System.out.println("over");

         }

}

*/

 

/*

1异常在子父类覆盖中的体现 如果父类的方法抛出异常 那么子类的覆盖方法 只能抛出父类的异常或者该异常的子类

2如果父类方法抛出多个异常 那么子类在覆盖该方法时 只能抛出父类异常的子集（不能超过父类）

3如果父类或者接口的方法中没有异常抛出 那么子类在覆盖方法时也不可以抛出异常

  如果子类方法发生了异常 必须进行try处理 绝对不能抛***

 

 

 

*/

 

class Aexception extends Exception

{

 

}

class Bexception extends Aexception

{

 

}

class Cexception extends Exception

{

 

}

/*

Exceotion

      |----Aexceotion

                    ----Bexceotion

            |----Cexceotion

*/

 

class Fu

{

         voidshow()throws Aexception

         {

 

         }

}

class Test

{

         voidfunction(Fu f)

         {

                   try

                   {

                            f.show();

                   }

                   catch(Aexception e)

                   {

                   }

         }

}

class Zi extends Fu

{

         voidshow()throws  Cexception

         {

 

 

         }

}

class Exceptiondemo5

{

         publicstatic void main(String[] args)

         {

                   Testt=new Test();

                   t.function(newFu());

         }

}