黑马程序员_Java异常处理机制

                ------- android培训、java培训、期待与您交流！ ----------                                 

1.      异常：

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

2.      异常体系：

Throwable

        |---Error

        |---Exception

               |---RuntimeException

3.      异常体系的特点：

异常体系中的所有类以及建立的对象都具有可抛性，也就是说可以被throw和throws 关键字所操作，只有异常体系具备这个特点。

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

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

5.      当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。注意：RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常，函数上可以不声明，程序将直接停止。

6.      如果函数声明了异常，调用者需要进行处理，处理方法可以Throws可以try

7.      异常有两种：

编译时被检测异常

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

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

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

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

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

8.  异常处理语句：

       try{}catch{}finally{}

       try{}catch{}

       try{}finally{}

注意：

(1)try代码块中，发生异常语句后面的代码是不会被执行的

(2)finally中的代码是一定被执行的，只有一种情况除外，那就是在try…catch中执行了System.exit(0);语句，System.exit(0);表示退出当前的java虚拟机。

8.      自定义异常：将程序中出现的特有问题进行封装

定义类继承Exception或者RuntimeException

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

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

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

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

class MyExceptionextends Exception{

    MyException(String message){

       super(message);

    }

}

9.异常好处：

    将问题进行封装

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

10.异常处理原则：

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

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

                            一个try对用多个catch

              (3)多个catch,父类的catch放到最下面

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

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

              try{

           throw new Aexception();

}catch(AException e){

           throw e;

}

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

       或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，也可以将捕获的异常处理后转换成新的异常

       try{

        throw new Aexception();

}catch(AException e){

        throw new BException();

}

11．异常的注意事项：

       在字符类覆盖时：

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

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

异常在字符类覆盖中的体现：

class AExceptionextends Exception{

   

}

class BExceptionextends AException{

   

}

class CExceptionextends Exception{

   

}

class Fu{

    void show()throws AException{

      

    }

}

class Zi extends Fu{

    void show()throws CException{

      

    }

}

class Test{

    void function(Fu f){

       try{

           f.show();

       }catch(AException e){

          

       }

    }

}

public class Demo {

    Test t=new Test();

    t.function(new Zi());

}

在上面的代码中，t.function(new Zi());将子类对象作为父类对象的引用，内部调用的是子类重写父类show()后的show()方法，而子类show()方法抛出的是CException异常的对象，

Catch(AExceptione){}无法处理CException异常。

12.在加一个小知识点：

       用代码证明，在try中写了return,后面有写了finally,是先执行return还是先执行finally?

    答案：先执行return.

public class Test6 {

    public static void main(String[] args){

       //编译运行,输出0，证明先执行return。

       System.out.println(num());

    }

   

     // 定义一个方法，依靠返回值来判断是先执行return还是先执行finally?

     // 输出0，则先执行return；输出1则先执行finally.

    public static int num(){

       int n=0;

       try{

           return n;

       }finally{

           n=n+1;

       }

    }

}