Overridden methods cannot throw exceptions Java [duplicate]

Answer 1

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.

Answer 2

The compiler complains that overridden methods cannot throw exceptions

No it doesn't. Read the message again. It says you can't throw an exception that isn't declared to be thrown by the overridden method. Not the same thing at all.

Answer 3

The rule says

"Subclass overridden method cannot throw more exceptions than that of super class method".

Answer 4

Subclass overriden method/methods can throw (Declare) only unchecked exception like ArrayIndexOutOfBoundsException.

But you can't throws (declare) the checked exception. like IOException.

example to overridden methods throw exceptions Java

class A{
 public void show(){
   // some code here
  }
}

class B extends A{
public void show() throws ArrayIndexOutOfBoundsException{
   // some code here
  }
}

Hope these may help you.

Answer 5

your above code in main method

Alpha g = new Beta(); // now it's create a new actual object of Beta class with refrence of Alpha

g.Gamma(); // * now compiler look only Gamma() method presents in Alpha class off cource it present in Beta class also by default through inheritance.but compiler looked only at class Alpha and ask a question is contains a method Gamma() and found a answer yes it has.

suppose a condition when java compiler gives facility to throws more checked exceptions in gamma() method in Beta Class then what will happen

• now at compile time compiler only depend on Gamma() method of class Alpha.it does not force to handle this exception or throws this exception which is wrong because it might throw(supposing to java compiler allow throwing more checked exception in overridden method). but in reality compiler not make restriction on throwing exceptions but also on accessibility modifier.

  because non static method invocation happen on actual object method not on type and we give to any super type and at compilation time compiler only check accessibility and presence in that type of assigned class.

so i think that's the reason behind this overridden contract

• The method definition cannot narrow the accessibility of the method, but it can widen it. • The method definition can only throw all or none, or a subset of the checked exceptions (including their subclasses) that are specified in the throws clause of the overridden method in the superclass.

Answer 6

Your client side always think to deal with the base version. That's the whole benefit of polymorphism => client side ignores the overriden one.

Thus, nothing will force the client to deal with specific rules made by the overriden, here the case of a potential exception thrown by the overidden method.

That's why an overriden method can't throw broader exceptions. It would break the contract.

Thus, regarding this logic, rule is: Overriden method CAN (if it want) only throw a subpart of the exceptions declared in the base version BUT CANNOT throw broader ones.