笔记整理（java基础六-----异常）

异常大纲：
1.6.1 java中异常的思想 
1.6.2 异常体系结构 
1.6.3 自定义异常 
1.6.4 异常的分类 
1.6.5 Throw与throws的区别 
1.6.6异常的捕捉形式 
1.6.7 代码快组合的特点 
1.6.7 异常的处理原则 
1.6.8 异常的注意事项 
1.6.9 Finally 

详细介绍开始吧：
异常：
      异常的由来：是在运行时期发生的不正常情况。1.6.1 java中异常的思想 
        用类的形式对不正常情况进行了描述和封装对象，这种类成为异常类。

    将正常流程代码和问题处理代码分离，提高了阅读性。不同的问题

    用不同的类进行具体的描述，例如：角标越界，空指针等等。

1.6.2 异常体系结构 
       
最终问题（不正常情况）就分成了两大类：

Throwable:

无论是error，还是异常，问题，问题发生就应该可以抛出，让调用者知道并处理。

该体系的特点就在于Throwable及其所有的子类都具有可抛性。

可抛弃到底指的是什么呢？怎么体现可抛性呢？

其实是通过两个关键字来体现的，throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。

         |----1,一般不可处理的。Error

                   特点：是由jvm抛出的严重性的问题。

                              这种问题发生一般不针对性处理，直接修改程序。

|----2,可以处理的。Exception

该体现的特点：

         子类的后缀名都是用其父类名作为后缀，阅读性很强。

1.6.3 自定义异常 
          定义异常

          让一个类称为异常类，必须要继承异常体系，因为只有异常体系子类才具备可抛性。

1.6.4 异常的分类 
   异常的分类：

编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。

这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。

这样的问题都可以针对性的处理。

2,编译时不检测异常(运行时异常)：就是Exception中的和RuntimeException和其子类。

         这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。

         那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

如果函数内发生了异常，就需要在函数上进行声明，否则编译失败。

你调用了发生异常的函数或声明异常的函数，你就必须要处理，不处理编译失败

示例代码：

对于角标是整数不存在，可以用角标越界表示，

对于负数为角标的情况，准备用负数角标异常来表示。

负数角标这种异常在java中并没有定义过。

那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述。并封装成对象。

这种自定义的问题描述成为自定义异常。

注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具备可抛性。

         才可以被两个关键字所操作，throws throw

class FuShuIndexException extends Exception

{

         FuShuIndexException()

         {}

         FuShuIndexException(String msg)

         {

                   super(msg);

         }

}

class Demo

{

         public int method(int[] arr,int index)//throws NullPointerException//FuShuIndexException

         {                 

                   if(arr==null)

                            throw new NullPointerException("数组的引用不能为空！");

                   if(index>=arr.length)

                   {

                            throw new ArrayIndexOutOfBoundsException("数组的角标越界啦，哥们，你是不是疯了？："+index);

                   }

                   if(index<0)

                   {

                            throw new FuShuIndexException("角标变成负数啦！！");

                   }

                   return arr[index];

         }

}

class  ExceptionDemo3

{

         public static void main(String[] args) //throws FuShuIndexException

         {

                   int[] arr = new int[3];

                   Demo d = new Demo();

                   int num = d.method(null,-30);

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

                   System.out.println("over");

         }

}     
1.6.5 Throw与throws的区别 
         throws使用在函数上，throws使用在函数内

     throws抛出的是异常类，可以抛出多个，用逗号隔开，而throw抛出的是异常对象throw可以用来结束函数。

1.6.6异常的捕捉形式 
        这是可以对异常进行针对性处理的方式。

具体格式是：

try

{

         //需要被检测异常的代码

}

catch(异常类 变量) //该变量用于接收发生的异常对象

{

         //处理异常的代码

}

finally

{

         //一定会被执行的代码。

}

函数上声明的是什么异常，我们就catch的是什么异常。

示例代码：

class FuShuIndexException extends Exception

{

         FuShuIndexException(){}

         FuShuIndexException(String msg)

         {

                   super(msg);

         }

}

class Demo

{

         public int method(int[] arr,int index)//throws NullPointerException,FuShuIndexException

         {        

                   if(arr==null)

                            throw new NullPointerException("没有任何数组实体");

                   if(index<0)

                            throw new FuShuIndexException();

                   return arr[index];

         }

}

class  ExceptionDemo4

{

         public static void main(String[] args)

         {

                   int[] arr = new int[3];                 

                   Demo d = new Demo();

                   try

                   {

                            int num = d.method(null,-1);

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

                   }

                   catch(NullPointerException e)

                   {

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

                   }

                   catch (FuShuIndexException e)

                   {

                            System.out.println("message:"+e.getMessage());

                            System.out.println("string:"+e.toString());

                            e.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。

                            System.out.println("负数角标异常!!!!");

                   }

                   /*

                   catch(Exception e)//多catch父类的catch放在最下面。

                   {

                   }

                   */

                   System.out.println("over");

         }

}

当有多个catch出现时应注意的事项：

示例代码：

1.6.7 代码快组合的特点 

     try catch finally

     try catch//不需要关闭资源

     try finally//异常无法直接catch处理，但是资源需要关闭。

          
1.6.7 异常的处理原则 

    函数内容如果抛出需要检测的异常，那么函数上必须声明，或者在

    函数内使用try catch捕捉，否则编译失败。

    如果调用到了声明异常的函数，要么try catch 要么throws 。否则编译失败。

什么时候使用catch，什么时候throws？

    功能内容可以解决，用catch。

       解决不了，用throws告诉调用者，有调用者处理。

一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。内部有几个需要检测的异常，就抛出几个异常，抛出几个，就catch几个。多catch时，父类必须放在最下面。

1.6.8 异常的注意事项 
        子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

如     如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

    简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。

    注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try.

       

异常练习示例：

示例代码：

需求：毕老师用电脑讲课。

public class ExceptionTest1 {

    /**

     * @param args

     */

    public static void main(String[] args) {

       Laoshi lao = new Laoshi("毕向东");

       try {

           lao.prelect();

       } catch (NoplayException e) {

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

           System.out.println("换人");

       }

    }

}

class LanpingleException extends Exception{

    LanpingleException(String message){

       super(message);

    }

}

class MaoyanleException extends Exception{

    MaoyanleException(String message){

       super(message);

    }

}

class NoplayException extends Exception{

    NoplayException(String message){

       super(message);

    }

}

class NoteBook{

    private int state =2;

    public void run() throws LanpingleException, MaoyanleException{

       if(state == 1)

           throw new LanpingleException("电脑蓝屏啦");

       if(state == 2)

           throw new MaoyanleException("电脑冒烟啦");

       System.out.println("电脑运行");

    }

    public void rest(){

       state = 0;

       System.out.println("电脑重启");

    }

}

class Laoshi{

    private String name;

    private NoteBook compu;

    Laoshi(String name){

       this.name = name;

       compu = new NoteBook();

    }

    public void prelect() throws NoplayException{

       try {

           compu.run();

           System.out.println(name+"开始讲课");

       } catch (LanpingleException e) {

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

           compu.rest();

           prelect();

       } catch (MaoyanleException e) {

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

           test();

           throw new NoplayException("由于课时进度无法继续的原因："+e.getMessage());

       }

    }

    public void test(){

       System.out.println("大家练习");

    }

}

1.6.9 Finally 
         通常用于关闭(释放)资源。