Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Overridden methods cannot throw exceptions Java [duplicate]

Tags:

java

This is my code block.

class Alpha{
    public void Gamma() {
        System.out.println("Alphas");
    }
}

class Beta extends Alpha{
    public void Gamma() throws Exception //Line 1
    {
        try {
            System.out.println("Betas");
        } catch(Exception e) {
            System.out.println("Exception caught");
        } finally {
            System.out.println("xfg");
        }
    }
    public static void main(String[] args) throws Exception {
        Alpha g = new Beta();
        g.Gamma();
    }
}

This code fails to compile because I have added "throws" in Line1.

The compiler complains that overridden methods cannot throw exceptions.

Why so ?.

Why cant an overridden method throw an exception ?.

Because I can override a method from a base class by adding n lines of code in the child's class implementation.

And these added code can throw an exception so why I cant use "throws" in the overridden method ?.

like image 647
UnderDog Avatar asked Aug 25 '13 05:08

UnderDog


People also ask

Can subclass overriding method declare an exception if parent class method doesn't throw an exception?

Conclusion: When parent-class method declares no exception, then child-class overriding-method can declare, No exception.

Which of the following method does not throw an exception?

overridden method of subclass may not throw any exception.

Can we override a method twice in same class?

Therefore, you cannot override two methods that exist in the same class, you can just overload them.


1 Answers

Overridden methods can throw Exceptions, so long as the method being overridden also throws the same Exceptions. You can't introduce new Exceptions.

So why can't you introduce a new Exception?

One of the central concepts of OOP is using abstract types, and that all subtypes may be treated as the abstract type. See Liskov Substitution Principle

The reason you can't introduce broader behaviour is that if the method from the abstract type (super class or interface) doesn't throw an Exception and you refer to your object as that type, you'd get unexpected behaviour:

Alpha alpha = new Beta();
// At this point, the compiler knows only that we have an Alpha
alpha.myMethod();

If Alpha's myMethod() doesn't throw an Exception, but Beta's does, we could get an unexpected Exception in the above code.

like image 132
Bohemian Avatar answered Sep 18 '22 21:09

Bohemian