涉及继承的异常声明及捕捉

当有继承发生时，会伴随着重载、覆写(包括接口方法的实现)、构造器的重写等行为。此时，如果基类或是接口的方法存在异常声明，那么导出类或是接口的实现类的对应方法该如何声明异常？同时对这些方法的调用该如何捕捉异常？下面就这2个问题进行探讨，你会看到，针对覆写和构造器的重写是2种完全不同的处理方式(针对重载则没有任何限制)。代码如下：

Java代码
1.//@file Example1.java  
2. 
3.class ExtException extends Exception {}  
4.class AnotherException extends Exception {}  
5. 
6.class Base  
7.{  
8.    public void func() {}  
9.      
10.    public void func2() throws Exception {}  
11.    public void func3() throws ExtException {}  
12.      
13.    public Base() throws Exception {}  
14.    public Base(int i) throws Exception {}  
15.    //public Base(float f) throws ExtException{} //Error No.5: every other constructor will call the default constructor; same as Error No.4  
16.}  
17. 
18.interface Inf  
19.{  
20.    public void func2() throws ExtException;  
21.    //public void func3() throws AnotherException; //Error No.3: base and interface conflicts  
22.      
23.    public void func4() throws Exception;  
24.    public void func5() throws Exception;  
25.}  
26. 
27.class ExtImp extends Base implements Inf  
28.{  
29.    //public void func()  throws ExtException{} //Error No.1: if base function has no exception declaration, overriding CANNOT add one  
30.      
31.    //public void func2() throws Exception {} //Error No.2: cannot implement interface; base and interface conflicts  
32.    public void func2() throws ExtException {} //implement interface and use Hint No.2  
33.      
34.    //public void func3() throws ExtException {} //Error No.3  
35.    //public void func3() throws AnotherException {} //Error No.3  
36.      
37.    public void func4() {} //Hint No.1: if base function has exception declaration, overriding CAN ommit  
38.    public void func5() throws ExtException {} //Hint No.2: if base function has exception declaration, overriding CAN declare ext exception  
39.      
40.    //public ExtImp() {} //Error No.4: ext's construcor must declare the exception the base constructor declare  
41.    public ExtImp() throws Exception {}   
42.    //public ExtImp() throws ExtException {} //Error No.4  
43.      
44.    public ExtImp(int i) throws Exception, ExtException {} //Hint No.3: once ext decalres throwing the base's exception, it CAN declare other exception (不一定非要是父类声明异常的子类), see Example2.java  
45.      
46.    //public ExtImp(float f) throws ExtException{} //Error No.5  
47.} 
//@file Example1.java

class ExtException extends Exception {}
class AnotherException extends Exception {}

class Base
{
public void func() {}

public void func2() throws Exception {}
public void func3() throws ExtException {}

public Base() throws Exception {}
public Base(int i) throws Exception {}
//public Base(float f) throws ExtException{} //Error No.5: every other constructor will call the default constructor; same as Error No.4
}

interface Inf
{
public void func2() throws ExtException;
//public void func3() throws AnotherException; //Error No.3: base and interface conflicts

public void func4() throws Exception;
public void func5() throws Exception;
}

class ExtImp extends Base implements Inf
{
//public void func()  throws ExtException{} //Error No.1: if base function has no exception declaration, overriding CANNOT add one

//public void func2() throws Exception {} //Error No.2: cannot implement interface; base and interface conflicts
public void func2() throws ExtException {} //implement interface and use Hint No.2

//public void func3() throws ExtException {} //Error No.3
//public void func3() throws AnotherException {} //Error No.3

public void func4() {} //Hint No.1: if base function has exception declaration, overriding CAN ommit
public void func5() throws ExtException {} //Hint No.2: if base function has exception declaration, overriding CAN declare ext exception

//public ExtImp() {} //Error No.4: ext's construcor must declare the exception the base constructor declare
public ExtImp() throws Exception {}
//public ExtImp() throws ExtException {} //Error No.4

public ExtImp(int i) throws Exception, ExtException {} //Hint No.3: once ext decalres throwing the base's exception, it CAN declare other exception (不一定非要是父类声明异常的子类), see Example2.java

//public ExtImp(float f) throws ExtException{} //Error No.5
}
Java代码
1.//@file Example2.java  
2. 
3.class ExtException extends Exception {}  
4.class AnotherException extends Exception {}  
5.class ThirdException extends Exception {}  
6.class FourthException extends ThirdException {}  
7. 
8.class Base  
9.{  
10.    public Base() {}  
11.    public Base(int i) throws ExtException {}  
12.    public Base(float f) throws ExtException {}  
13.      
14.    public void func() throws ThirdException { System.out.println("Base.func()");}  
15.}  
16. 
17.class Ext extends Base  
18.{  
19.    public Ext() throws Exception {}  //Hint No.4: ext's constructor CAN add exception declaration  
20.    public Ext(int i) throws ExtException, AnotherException {} //Hint No.4  
21.    public Ext(float f) throws Exception {} //Hint No.5: ext's constructor can declare base exception  
22.      
23.    public void func() throws FourthException { System.out.println("Ext.func()");}  
24.}  
25. 
26.public class Example2  
27.{  
28.    public static void main(String[] args)  
29.    {  
30.        try 
31.        {  
32.            Ext e = new Ext(5);  
33.            e.func();  
34.        }  
35.        catch (ExtException ee) {}  
36.        catch (AnotherException ae) {}  
37.        catch (FourthException fe) {} // ***DIFFERENCE***  
38.      
39.        try 
40.        {  
41.            Base b = new Ext(5);  
42.            b.func();  
43.        }  
44.        catch (ExtException ee) {}  
45.        catch (AnotherException ae) {}  
46.        catch (ThirdException te) {} // ***DIFFERENCE***  
47.    }  
48.}  
49. 
50.//output:  
51./* 
52.    Ext.func() 
53.    Ext.func() 
54.*/ 
//@file Example2.java

class ExtException extends Exception {}
class AnotherException extends Exception {}
class ThirdException extends Exception {}
class FourthException extends ThirdException {}

class Base
{
public Base() {}
public Base(int i) throws ExtException {}
public Base(float f) throws ExtException {}

public void func() throws ThirdException { System.out.println("Base.func()");}
}

class Ext extends Base
{
public Ext() throws Exception {}  //Hint No.4: ext's constructor CAN add exception declaration
public Ext(int i) throws ExtException, AnotherException {} //Hint No.4
public Ext(float f) throws Exception {} //Hint No.5: ext's constructor can declare base exception

public void func() throws FourthException { System.out.println("Ext.func()");}
}

public class Example2
{
public static void main(String[] args)
{
try
{
Ext e = new Ext(5);
e.func();
}
catch (ExtException ee) {}
catch (AnotherException ae) {}
catch (FourthException fe) {} // ***DIFFERENCE***

try
{
Base b = new Ext(5);
b.func();
}
catch (ExtException ee) {}
catch (AnotherException ae) {}
catch (ThirdException te) {} // ***DIFFERENCE***
}
}

//output:
/*
Ext.func()
Ext.func()
*/

　　针对覆写方法，有以下几点原则：

　　1. 如果基类方法没有声明异常，那么导出类的覆写方法也不能声明异常(Error No.1)。

　　2. 如果基类方法有声明异常，那么导出类的覆写方法可以：(1)不声明异常；(2)声明抛出基类方法的异常；(3)声明抛出基类方法异常的导出类。(Hint No.1 & Hint No.2)

　　3. 如果基类和接口有同签名方法，且导出类实现了接口，如果基类方法和接口方法声明的异常不同，则称基类与接口冲突。如果基类方法抛出的异常和接口方法声明的异常存在继承关系，则实现接口的导出类必须声明抛出导出异常(子异常)(Error No.2)；如果如果基类方法声明的异常和接口方法声明的异常不存在继承关系，则冲突不可调和，需要修改基类或是接口(Error No.3)。

　　4. 由Example2.java可见，对于向上转型Base b = new Ext(5)，调用b.func()虽然会动态绑定调用Ext的func()方法，可是异常捕捉必须按照Base的func()方法的异常声明来捕捉(见DIFFERENCE处)。



　　针对构造器的重写，有以下几点原则：

　　1. 这里应该持这么一种观点，基类的带参构造器和导出类的所有构造器都默认调用了基类的默认构造器，Base(int i)调用了Base()，Ext()调用了super()，Ext(int i)调用了super(i)，依次类推。所以一旦基类的默认构造器声明了异常，那么基类的带参构造器和导出类的所有构造器都必须声明异常，异常类型可以是基类默认构造器的异常或是其基类，而决不能是其导出类(Error No.4, Error No.5 & Hint No.5)。



p.s. 导出类构造器虽然不能声明导出异常，不过可以抛出导出异常，如：

Java代码
1.class Base  
2.{  
3.    public Base() throws NullPointerException {}   
4.}  
5. 
6.class Ext extends Base   
7.{  
8.    public Ext() throws Exception  
9.    {  
10.        throw new NullPointerException();  
11.    }  
12.} 
class Base
{
public Base() throws NullPointerException {}
}

class Ext extends Base
{
public Ext() throws Exception
{
throw new NullPointerException();
}
}所以牢记：声明异常和实际抛出异常完全是两码事。



　　2. 如1.所说，构造器的重写实际是调用关系，所以一旦默认构造器没有声明异常，那么其他构造器就可以随便添加异常声明(Hint No.3 & Hint No.4)。