黑马程序员技术交流社区

标题: 异常处理演示 [打印本页]
作者: Synaric    时间: 2015-10-1 11:04
标题: 异常处理演示
如果异常具有继承体系，而我们的类也继承了某类且实现了接口，情况就复杂了
刚敲的例子：
  1. //定义一个异常的继承体系
  2. class BaseException extends Exception{}
  3. class StormException extends Exception{}
  4. class RainedOut extends StormException{}
  5. class AException extends BaseException{}
  6. class BException extends BaseException{}
  7. class UpperAException extends AException{}

  9. /*                                         |AException--------|UpperAException
  10. *                   |BaseException--------|
  11. * Exception---------|                     |BException
  12. *                   |
  13. *                   |StormException-------|RainedOut
  14. * */

  16. //演示抽象类的异常处理
  17. abstract class Inning{
  18.         public void Inning() throws BaseException{}
  19.         public void event() throws BaseException{}
  20.         public abstract void atBat() throws AException, BException;
  21.         public void walk(){}    //不抛出任何异常
  22. }

  24. //演示接口的异常处理
  25. interface Storm{
  26.         public void event() throws RainedOut;    //和抽象类一样的方法，不同异常声明
  27.         public void rainHard() throws RainedOut;
  28. }

  30. //这是我们的主要关注点
  31. class StormyInning extends Inning implements Storm{
  32.         //能为构造器添加新的异常，但必须处理已有的异常
  33.         public StormyInning() throws BaseException, RainedOut{}       
  34.         public StormyInning(String s)throws BaseException, AException{}
  35.        
  36.         //不能添加新的异常
  37.         //public void walk() throws AException{}
  38.        
  39.         //接口不能为父类继承来的方法添加新的异常
  40.         //可以不写父类的异常声明
  41.         public void event(){}
  42.        
  43.         //如果不是父类方法，则可以
  44.         @Override
  45.         public void rainHard() throws RainedOut {}
  46.        
  47.         //重写的方法可以抛出父类声明的异常的子类
  48.         @Override
  49.         public void atBat() throws UpperAException {}
  50. }

  52. public class ExceptionDemo3 {
  53.         public static void main(String[] args) {
  54.                 try {
  55.                        
  56.                         //s1必须初始化，因为有可能构造失败
  57.                         StormyInning s1 = null;
  58.                         //用子try-catch处理构造函数异常
  59.                         try {
  60.                                 s1 = new StormyInning();
  61.                         } catch (RainedOut e) {
  62.                                 e.printStackTrace();
  63.                         } catch (BaseException e) {
  64.                                 e.printStackTrace();
  65.                         }
  66.                         s1.atBat();
  67.                        
  68.                 } catch (UpperAException e) {
  69.                         System.out.println("UpperAException");
  70.                 }
  71.                
  72.                 //看看向上转型会发生什么
  73.                 Inning s2 = null;
  74.                 try {               
  75.                         s2 = new StormyInning();       
  76.                 } catch (RainedOut | BaseException e) {
  77.                         //必须处理基类声明的异常
  78.                         System.out.println("RainedOut");
  79.                 }
  80.                
  81.                 //只能抛出基类声明的异常
  82.                 try {
  83.                         s2.atBat();
  84.                 } catch (AException | BException e) {
  85.                         System.out.println("A or BException");
  86.                 }
  87.         }
  88. }
复制代码







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2