黑马程序员_异常

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

1.异常的体系：

Throwable

|----Error（严重问题，不能解决的问题，出现这种问题程序必须停掉）

|----Exception（非严重的问题，出现这种问题，可以解决，问题解决后，程序还可以运行）
      |-----RuntimeException(运行时检测异常，也叫做不检测异常)
      |----编译时检测异常

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

理解了异常体系的特点后，才可以自定义异常。（自定义异常需要extends异常体系）

2.Throwable 类的方法主要有：

public String toString()//返回此 throwable 的简短描述。

public String getMessage()//返回此 throwable 的详细消息字符串。

public void printStackTrace()//将此 throwable 及其追踪输出至标准错误流。

3.发生异常后如何处理

处理方式一：声明处理

方法有异常抛出的时候，需要 throws 声明，来提醒使用方法的对象，必须处理这个异常。如果是 RuntimeException 异常的时候，可以不用声明。

throw 关键字是用来抛出异常对象的。

throws和throw有什么区别？

(a)throw用在函数内，后面跟的是异常对象；throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常类，可抛出多个。
(b)throws可以单独使用；但throw不能， throw要么和try-catch-finally语句配套使用，要么与throws配套使用。
(c)throw程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

(d)throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。

处理方式二：捕捉处理

try{

}catch( Exception e ){

}finally{

}

try-catch-finally的几种组合形式：

(a)try catch finally
(b)try catch(多个)当没有必要资源需要释放时，可以不用定义finally。
(c)try finally  异常无法直接catch处理，但是资源需要关闭。

根据 java 规范：在 try-catch-finally 中，如果 try-finally 或者 catch-finally 中都有 return，则两个 return 语句都执行并且最终返回到调用者那里的是 finally 中 return 的值；而如果finally 中没有 return，则理所当然的返回的是 try 或者 catch 中 return 的值，但是 finally 中的代码是必须要执行的,而且是在 return 前执行，但是会先执行 try 或者 catch 中的 return 语句中 return 后面跟的表达式，只是不执行 return，return 对应的 jvm 指令是 areturn ，等 finally 里面执行完了之后再执行 return ，除非碰到 System.exit()，只有代码中有system.exit() 这一种情况 才不会执行 finally  因为终止了虚拟机进程 。

4.异常处理的原则：

(a)函数内容如果抛出需要检测的异常，那么函数上必须要声明。否则必须在函数内用trycatch捕捉，否则编译失败。
(b)如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。
(c)什么时候catch，什么时候throws  呢？功能内容可以解决，用catch；解决不了，用throws告诉调用者，由调用者解决  。
(d)一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。父类catch块放最下面。

5.异常的注意事项：

（a）子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
（b）如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。 
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try .

6.自定义异常：

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

下面是一段自定义异常的示例代码：

[java] view plaincopy

1. class FuShuIndexException extends Exception//RuntimeException  

2. {  

3.     FuShuIndexException(){}  

4.     FuShuIndexException(String msg)  

5.     {  

6.         super(msg);//直接调用父类的方法  

7.     }  

8. }  

 7.异常处理示例

[java] view plaincopy

1. class LanpingException extends Exception  

2. {  

3.     LanpingException(String message)  

4.     {  

5.         super(message);  

6.     }  

7. }  

8. class MaoyanException extends Exception  

9. {  

10.     MaoyanException(String message)  

11.     {  

12.         super(message);  

13.     }  

14. }  

15. class NoplanException extends Exception  

16. {  

17.     NoplanException(String message)  

18.     {  

19.         super(message);  

20.     }  

21. }  

22.   

23. class Computer  

24. {  

25.     private int state=3;  

26.     public void run()throws LanpingException,MaoyanException  

27.     {  

28.         if(state==2)  

29.             throw new LanpingException("蓝屏");  

30.         if(state==3)  

31.             throw new MaoyanException("冒烟");  

32.         System.out.println("运行");  

33.     }  

34.     public void reset()  

35.     {  

36.         state=1;  

37.         System.out.println("重启");  

38.     }  

39. }  

40. class Teacher  

41. {  

42.     private String name;  

43.     private Computer c;  

44.     Teacher(String name)  

45.     {  

46.         this.name=name;  

47.         c=new Computer();  

48.     }  

49.     public void prelect()throws NoplanException  

50.     {  

51.         try  

52.             {  

53.                 c.run();  

54.             }  

55.         catch (LanpingException e)  

56.         {  

57.             c.reset();  

58.         }  

59.         catch(MaoyanException e)  

60.         {  

61.             test();//test功能写在抛前边，因为抛出异常程序就停止了。  

62.             throw new NoplanException("课时无法继续"+e.getMessage());  

63.         }  

64.         System.out.println("讲课");  

65.     }  

66.   

67.     public void test()  

68.     {  

69.      System.out.println("练习");  

70.     }  

71. }  

72. class ExceptionTest1  

73. {  

74.     public static void main(String[] args)  

75.     {     

76.     Teacher t=new Teacher("毕老师");     

77.     try   

78.         {     

79.             t.prelect();      

80.         }     

81.     catch (NoplanException e)     

82.         {     

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

84.             System.out.println("换老师");    

85.         }     

86.     }  

87. }