面向对象_异常总结

1.什么是异常？其由来？
  异常：就是程序在运行时出现不正常情况

  异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述

                    并封装成对象，其实就是java对不正常情况进行描述后的对象体现
————————————————
2、异常体系：
  
   异常的划分：一种是严重的问题，一种是非严重的问题

   对于严重的，java通过Error类进行描述，对于Error一般不编写针对性的代码对其处理

   对于非严重的，java通过Exception进行描述，对于Exception可以使用针对性的处理方式进行处理

 Error和Exception都是一些共性内容，比如不正常信息，引发原因等
 
异常的结构体系：
 Throwable
      |——Error
      |——Exception
           |——RuntimeException
     异常体系的特点：异常体系中的所有类以及建立的对象都具备可跑性。
————————————————
3、异常的分类
  两种：
  1、编译时被被检测异常（Exception）
     该异常在编译时，如果没有处理（没有抛也没有try）,编译失败
  2、运行时异常（编译时不检测，因为该异常发生时，建议不处理，让程序停止，需要对代码进行修正）(RuntimeException)如：ArithmeticException, NullPointerException, IndexOutOfBoundsException等之类的异常可以不用显式的捕获或者抛出。
————————————————
4、异常的处理

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

  try

  {

         需要检测的代码

  }

  catch(异常类变量)

  {

         处理异常的代码；(处理方式)

  }

  finally

  {

         一定会执行的语句；

  }
注意：1、finally中定义的通常是 关闭源代码。因为资源必须释放。
      2、finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行，因为jvm已经关闭

****finally语句
finally语句，可以和try语句一起使用。记住一点就OK，程序一定要执行的语句。
  为了防止用户一直保持对某个对象的引用，即“内存泄露”，会极大的消耗内存（比如服务器中的数据库），所以要用 对象名.close();语句来关闭某个对象的引用，而这个语句因为如果在try块出现了程序异常，那么很有可能在解决完异常后，程序直接return，就无法关闭套接字了。那么把关闭套接字，放在finally语句中就没问题了。程序一定要执行~

try语句的3种基本格式：
1、try
     {
     }
   catch
     {
     }
   finally
     {
     }
2、try
     {
     }
   catch
     {
     }
3、try
     {
     }
   finally
     {
     }
最后一种也是可以的，但是函数上必须得抛出，因为没有catch语句进行处理。而finally中就写2种东西，一，是必须要执行的语句；二、则是为了关闭资源，因为抛出异常后，调用者很可能也不进行资源的关闭~~！

 

————————————————
5、异常的处理原则：

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

         2.对方声明几个异常，就对应几个catch块，不要定义多个多余的catch块
            注意：声明异常时建议声明和更为具体的异常，这样处理的更具体
          
         3.如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

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

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

           try
           {
                  throw new AException();
           }
           catch(AException e)

           {
                  throw e;
           }

           如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，

           再抛出和该功能相关的异常。

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

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

           try

           {
                  throw new AException();
           }

           catch(AException e)
           {
                  //在抛出BException前，对AException处理，即输出AException没处理成功

                  throw new BException();
           }

****
throw和throws的用法：

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

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

因为项目中会出现特有的问题，
而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题，进自定义的异常封装。

自定义类必须继承Exception或者RuntimeException

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

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

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

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

         class MyException extends Exception

         {

                  MyException(String message)

                  {

                          super(message);

                  }

         }
————————————————
7、异常的好处：

         1.将问题进行封装对象

         2.将正常流程代码和问题代码相分离，方便阅读
————————————————
8、
异常在子父类覆盖中的体现：
1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者改异常的子类。
2、如果父类抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常和其子集。
3、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。（即要解决了）

下面这个例子能很好的说明：
class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}

class Fu
{
  void show()throws AException
  {
  }
}
class Zi extends Fu
{
  void show()throws CException
   {
   }
}
class Test
{
    void function(Fu a)
   {
        try
      {
         a.show();
      }
        catch(AException e)
       {
       }
       
   }
}
class MakLove
{
  public static void main(String[] args)
  {
       Test x=new Test();
        x.function(new Fu());  //这样毫无疑问 OK
        x.function(new Zi());  /*但这样就挂了，因为方法覆盖的原因，所以方法function是没有解决父类以外的异常的，所以，这样编译一定失败。1、2点就体现了，而第3点呢，如果父类没抛，说明父类已经解决了，或者没有异常，换而言之，在function()中就没有catch语句了。所以子类只能自己解决，如果抛出，在function()中也解决不了。记住：继承的原则是先有父，后有子，所以function()中只有父类的catch，而后来的子类要+也是OK的，不过得修改程序了，一旦程序多了，这样做就有可能修改一大票，况且类又各种具有封装性，所以才有了这些规定。*/
  }
}