Java异常的限制

Java异常的限制

我在看JAVA编程思想，讲到异常的限制，看的代码和解释，非常的难看下去，直接写了他的代码。

java编程思想关于异常限制的逻辑

它以棒球比赛为例子。

定义了Inning(一局比赛)抽象类，构造器抛出异常，三个行为：event、atBat、walk，最顶层的一个异常BaseballException ，它有个子类异常是Foul(犯规)，Strike(动手)。

定义了一个接口Storm(暴风雨）,它有两个行为event(事件)、rainHard(雨下的太大)，与它关联的有两个异常，父异常StormException ，子异常RainedOut 。

请注意抽象类Inning和接口Storm都有一个event方法。

StormyInning 继承抽象类Inning和实现了接口Storm

异常的限制到底有哪些

我们从构造器，方法的重写，向上转型这几个方面总结

构造器：

  父类与接口的异常必须解决，不然你怎么说你继承、实现它呢
  子类的构造器当然可以抛出新的异常

重写：

子类要可以继承异常也可以不继承异常，可以少抛、多抛异常
如果冲突，就不要抛了。
重写并不以异常种类和多少作为区分啊，所以你可以不抛的

向上转型构造器

编译器一定会提示你抛父类的异常

java编程思想中关于异常限制的代码

package exceptions;
//: exceptions/StormyInning.java
// Overridden methods may throw only the exceptions
// specified in their base-class versions, or exceptions
// derived from the base-class exceptions.

class BaseballException extends Exception {}
class Foul extends BaseballException {}
class Strike extends BaseballException {}

abstract class Inning {
  public Inning() throws BaseballException {}
  public void event() throws BaseballException {
    // Doesn't actually have to throw anything
  }
  public abstract void atBat() throws Strike, Foul;
  public void walk() {} // Throws no checked exceptions
}

class StormException extends Exception {}
class RainedOut extends StormException {}
class PopFoul extends Foul {}

interface Storm {
  public void event() throws RainedOut;
  public void rainHard() throws RainedOut;
}

@Slf4j
public class StormyInning extends Inning implements Storm {
    // 构造器需要继承的异常是BaseballException，也可以新增异常
    public StormyInning() throws BaseballException, RainedOut {

        //
        throw new BaseballException();
    }

    @Override
    public void rainHard() throws RainedOut {

    }

    //
    @Override
    public void atBat() throws PopFoul {
        throw new PopFoul();
    }

    // storm和Inning的方法都跑出了异常，不兼容，这个方法不能抛这两个异常
    public void event() {

    }

    public static void main(String[] args) {
        log.info("Begin test");
        try {
            StormyInning si = new StormyInning();
            si.atBat();
        } catch (PopFoul e) {
            log.warn("PopFoul:", e);
        } catch (RainedOut e) {
            // TODO Auto-generated catch block
            log.warn("RainedOut:", e);
        } catch (BaseballException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            log.warn("BaseballException:", e);
        }

        Inning i;
        try {
            i = new StormyInning();
            i.atBat();
        } catch (RainedOut e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BaseballException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (Strike e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Foul e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}