Exception handling in overriding a method

[Tarun Mohandas]

Lets consider a code

class Animal{
public void eat()
{
   System.out.println("Animal eats");
}
}
class Cow extends Animal
{
  public void eat()
{
System.out.println("Cow eats");
}
}
class Test
{
public static void main(String[] args){  
Animal a = new Cow(); 
a.eat(); //Prints Cow eats
}
}

Since reference variable of type Animal is pointing to a Horse Object, when eat() is invoked it invokes the overrided method eat() which prints Cow eats

Now consider this code

class Animal{
public void eat() throws Exception
{
}
}
class Cow extends Animal
{
  public void eat() //doesnt throw exception
{

}
}
class Test
{
public static void main(String[] args){  
Animal a = new Cow(); 
a.eat(); //Error
}
}

If we consider the previous code the ref variable clearly invokes the overrided method. But in this code why does it call the superclass method and produce an error? Since no exceptions are thrown it is less broader than the super class exception. Why does this produce error? Can someone please clearly explain it to me? I cannot understand how exceptions work in overriding.

[Matthew Brown]

Working out exactly which version of the method will be called is done at runtime, and depends on the actual type of the object. But checking of checked exceptions is done by the compiler. And the compiler only considers the type of the reference.

So in this case the compiler has no idea what the actual type is going to be. All it knows is that you're calling eat() on an Animal reference. And it knows that the eat() method of an Animal might throw an Exception. This is a checked exception, so it's an error if you're not handling it.

It's an error for exactly the same reason as this is an error:

class Animal {}
class Cow extends Animal {
    void moo() {...}
}

...

Animal animal = new Cow();
animal.moo();

Here it's trying to call a method that isn't defined in the reference type of the variable. Yes, the moo() method exists in the Cow class, but as far as the compiler is concerned it could be any Animal.

[Mansukhdeep Thind]

If we consider the previous code the ref variable clearly invokes the overridden method. But in this code why does it call the super class method and produce an error? Since no exceptions are thrown it is less broader than the super class exception. Why does this produce error? Can someone please clearly explain it to me? I cannot understand how exceptions work in overriding.

The correct approach is quintessential in isolating the problem in such cases. Approach such cases in the following manner:

a) Method overriding comes in to play only at run time i.e. if your code compiles correctly and then you get different behavior when you run it depending on the type of object on the heap. There is no overriding in play at compile time in the second example you quoted. So, clearly it has got to do something with checked exception handling and NOT method overriding.

b) All other method calls are resolved at compile time based on the reference type of the object. Compiler checks for checked exceptions to be handled or declared at compile time. It sees that the Animal class eat() method declares a checked exception of type Exception. So, it shall force you to either handle or declare the same when you call that method. That is a rule for handling checked exceptions in Java language.

Let me know if you have any further doubts regarding the same.

[Ishan Pandya]

Compiler always check the super class method first before executing the sub class method. and if there is a possibility that it throws the checked exception then it gives a compile time error before executing further.

[Matthew Brown]

Ishan Pandya wrote:Compiler always check the super class method first before executing the sub class method. and if there is a possibility that it throws the checked exception then it gives a compile time error before executing further.

That's not true in general, as the following code would show:

Cow cow = new Cow();
cow.eat();

That will compile fine - no checking of the superclass method is involved. The difference is the reference type of the variable - and that's the version the compiler checks regardless of what superclasses might exist.

[Tarun Mohandas]

I had a hard time understanding what gets decided at compile time and what at runtime. Now I am clear. Thanks for the answers and the very helpful tip regarding the runtime/compile time actions.

[Ishan Pandya]

That's not true in general, as the following code would show:

thanks for correcting i actually meant somewhat that only..