Invoking overriding method that throws Checked exception

Question

After reading Why can't overriding methods throw exceptions, I understand that if method declared as throws a Checked exception, the overriding method in a subclass can only declare to throw that exception or its subclass:

class A {
   public void foo() throws IOException {..}
}

class B extends A {
   @Override
   public void foo() throws SocketException {..} // allowed

   @Override
   public void foo() throws SQLException {..} // NOT allowed
}

So because SocketException IS-A IOException I can declare the overriding method as throws any of subclass of IOException.

In my program, I want to invoke the overriding method declared as throws FileNotFoundException IS-A IOException. also handled with a try-catch block

import java.io.*;
class Sub extends Super{
    public static void main (String [] args){
        Super p = new Sub();
        try {
            p.doStuff();
        }catch(FileNotFoundException e){

        }
    }
    public void doStuff() throws FileNotFoundException{}
}

class Super{
    public void doStuff() throws IOException{}
}

But I am getting that compile-time error:

Sub.java:6: error: unreported exception IOException; must be caught or declared to be thrown
                    p.doStuff();
                             ^

What is the reason for that? I'm a little confused because everything that the Base class has also available to the subclasses.

Also much more confusing is the ability to catch Exception and Throwable In addition to IOException (The opposite from Overriding concept).

Some people may have images blocked. Can you also copy paste the compilation error in your question. — Chetan Kinger, Jan 24 '17 at 11:25

StuPointerException · Answer 1 · 2017-08-15T19:23:09.763

14

Your object reference is of type Super, even though you know it's a Sub object at runtime. Therefore the compiler is checking the method definition of the Super and giving you this compile error.

It would be no different from getting the following compiler error:

Object o = new String("Hello World");
o.charAt(2); //Obviously not allowed

It's important to remember that the throws clause is part of the method definition.

edited Aug 15 '17 at 19:23

answered Jan 24 '17 at 11:27

StuPointerException

7,117
5
29
54

1

But, java.lang.Object don't have `charAt` method While both `Super` and `Sub` has – Pauwelyn Jan 24 '17 at 11:56
3

Agreed. However the principal is exactly the same, the compiler only checks that the methods you are calling are on the reference type (`Object` in my example, `Super` in your case). – StuPointerException Jan 24 '17 at 12:17

Chetan Kinger · Accepted Answer · 2017-01-24T18:45:16.900

What is the reason for that? I'm a little confused because everything that the Base class has also available to the subclasses.

You need to catch an IOException and not a FilenotFoundException. This is because of the fact that while the doStuff method from the subclass will be called at runtime, the compiler doesn't know about this yet. It only knows about the doStuff method in the super class which declares that it throws an IOException.

To address your edit : The catch block can chose to catch the exact exception that is expected in the try block or it can chose to catch a superclass of the exception. The reasoning behind this has got nothing remotely to do with method overriding.

score 5 · Answer 3 · answered Jan 24 '17 at 11:32

5

The compiler doesn't consider the type of the object, but the type of reference you are using which is Super.

As Super.doStuff() throws IOException, this is what you must catch.

BTW I highly recommend using an IDE, you will find it more productive.

answered Jan 24 '17 at 11:32

Peter Lawrey

525,659
79
751
1,130

How come I can use also `Exception` and `Throwable` In addition to `IOException`? That's opposite from Overriding that can only declare to throw that exception or its subclass – Pauwelyn Jan 24 '17 at 13:04
@Pau the overridden method cannot throw these but you can catch them – Peter Lawrey Jan 24 '17 at 13:13

score 3 · Answer 4 · answered Jan 24 '17 at 15:18

By declaring p as Super

Super p = ...

your Compiler only knows p is some kind of Super. Super's doStuff() throws an IOException, but your code catches only a special case of IOException, the FileNotFoundException. If you want to tell your Compiler this is definetly a Sub and not a Super just declare p as Sub.

In this case it's explicit not declared as Sub but as Super so any Super or its Childs might occur and throw any IOException which might not be a FileNotFoundException or any of it's childs.

score 2 · Answer 5 · answered Jan 24 '17 at 11:27

2

That's because you are using an object of static type Super. The compiler can not know that at runtime p is pointing to a Sub object, so it wants to catch the exceptions thrown by the method declared in the Super class

answered Jan 24 '17 at 11:27

Michele Da Ros

856
7
21

score 2 · Answer 6 · answered Jan 24 '17 at 11:31

Because it makes checks by declared type, in this case Super.

It is not known (or checked) that your p will contain only instances of Sub. Also, it would not make sense to define a superclass variable and use it only and only for 1 particular subclass.

So your Super p contains instance of a Super.class. Its method doStuff() can throw everything that extends IOException, lets say UnsupportedEncodingException, but you try-catch only for FileNotFoundException, so that Unsupported... may have been thrown and must be handled.

Invoking overriding method that throws Checked exception

6 Answers6