具有检查异常的覆盖方法

Question

I have two classes, A and B, where B extends A. I'm having a problem where B introduces an additional feature that comes with an exception ExceptionC that doesn't apply in any way shape or form to A, but it won't compile unless A specifies that it throws ExceptionC . I understand that this is by design (because of the Liskov Substitution Principle). My question is twofold:

1. What is the reasoning behind the Liskov Substitution Principle? If B extends A, shouldn't it be able to add more features and therefore exceptions?
2. What would be a better way to do this? It feels wrong to add a non-applicable exception to the superclass.

Specific situation:

I am writing an implementation of Ultimate Tic-Tac-Toe in Java. Basically take a tic-tac-toe grid and fill it with tic-tac-toe grids, like this:

 | | # | | # | | 
 | | # | | # | | 
 | | # | | # | | 
#################
 | | # | | # | | 
 | | # | | # | | 
 | | # | | # | | 
#################
 | | # | | # | | 
 | | # | | # | | 
 | | # | | # | |

You start in the center, and wherever X goes in that grid, O goes in the grid corresponding to that on the larger one, so after two moves it might look like this:

 | |O# | | # | | 
 | | # | | # | | 
 | | # | | # | | 
#################
 | | #X| | # | | 
 | | # | | # | | 
 | | # | | # | | 
#################
 | | # | | # | | 
 | | # | | # | | 
 | | # | | # | |

And if the target grid is full or has already been won, the next person can choose which grid to go in.

I have two normal classes, two exception classes, and an interface.

• TTTBoard implements Board
• UltimateTTTBoard extends TTTBoard implements Board
• TTTBoard.move throws LocationTakenException
• UltimateTTTBoard.move throws LocationTakenException,TargetBoardFullException

Note that in standard tic-tac-toe, there is only one board so TargetBoardFullException is completely non-applicable.

Am I doing this wrong? Should I not be using exceptions for this?

Answer 1

The following code shows why Java doesn't allow changing the contract:

class A {
    public void method() {
        // do something
    }
}

class B extends A {
    public void method() throws IOException {  // <- compile error here
        // do something and throw and exception
    }
}

class App {
    public static void main(String[] args) {
        A a = new B();
        a.method();  // to try or not to try, that's the question now.
    }
}

Of course, it doesn't compile. But if it would, would we have to catch an IOException in the main method (because it's a B instance) or not (because we call the method on the interface)?