之前，看异常处理部分的视频的时候老师有说过，在接口实现过程中，为了让异常不污染接口。所以通常接口的部分异常可以用RuntimeException封装。

如下代码：

1. import java.io.IOException;
   
2. import java.sql.SQLException;
   
3. 
   
4. /**
   
5. * 用于获取数据长的接口
   
6. * @author CBY
   
7. *
   
8. */
   
9. interface MyDataSourse {
   
10.         //获取数据
    
11.         String getData();       
    
12. }
    
13. /**
    
14. * 从数据库获取数据
    
15. * @author CBY
    
16. *
    
17. */
    
18. class MyDataSourseFromDB implements MyDataSourse {
    
19.         @Override
    
20.         public String getData() {
    
21.                 try {
    
22.                         //与数据库交互，可能上抛SQLException异常
    
23.                         throw new SQLException("数据库异常");
    
24.                 } catch (SQLException e) {
    
25.                         //为了不污染接口，需要封装成RuntimeException的子类异常
    
26.                         throw new RuntimeException(e.getMessage(),e);
    
27.                 }
    
28.         }
    
29. }
    
30. /**
    
31. * 从网络获取数据
    
32. * @author CBY
    
33. *
    
34. */
    
35. class MyDataSourseFromNet implements MyDataSourse {
    
36.         @Override
    
37.         public String getData() {
    
38.                 try {
    
39.                         //与网络交互，可能上抛IOException异常
    
40.                         throw new IOException("网络异常");
    
41.                 } catch (IOException e) {
    
42.                         //为了不污染接口，需要封装成RuntimeException的子类异常
    
43.                         throw new RuntimeException(e.getMessage(),e);
    
44.                 }
    
45.         }
    
46. }

复制代码

这些实现，对上层调用者来说，应该是透明的。
那我如何能让上层调用者知道，存在这种异常上抛的情况呢？

你的上层调用者，再调用这个方法的时候，编译器就会提醒捕获或者继续抛出该异常的。

Engle 发表于 2014-4-2 10:44
你的上层调用者，再调用这个方法的时候，编译器就会提醒捕获或者继续抛出该异常的。 ...

对于上抛的RuntimeException及其子类，编译器是不提示的吧。

既然是为了不污染接口，那么子类覆盖的方法也不能抛出异常，必须try处理;
然后方法中若是捕获到了异常，仍没处理，那么只有抛出运行时异常才可以不用在函数上声明;
而运行时异常编译器不检查，对于这类异常一般不处理，那么程序就直接停止了，上层就不会知道了。
也就是说可能上抛的这个异常“为了不污染接口“并没有上抛。这是我的理解