deadly diamond of death syndrome :)

[Lucas Smith]

Please, have a look:

import java.io.*;

 public class Cast implements InterfaceC {
     public static void main(String[] args){
         
     }
     
     public void method() throws FileNotFoundException{}  //This is the only one checked exception we can declare
 }
 
 interface InterfaceA{
	 void method() throws IOException;
	 
 }
 
 interface InterfaceB{
	 void method() throws FileNotFoundException;
 }
 
 interface InterfaceC extends InterfaceA, InterfaceB{
	 
 }


     

The second one:

 
import java.text.*;
import java.io.*;

 public class Cast implements InterfaceC {
     public static void main(String[] args){
         
     }
     
     public void method() throws RuntimeException{} //only unchecked exception can be declare or no exception
 }
 
 interface InterfaceA{
	 void method() throws IOException;
	 
 }
 
 interface InterfaceB{
	 void method() throws ParseException;
 }
 
 interface InterfaceC extends InterfaceA, InterfaceB{
	 
 }

//look out! InterfaceC is not equivalent to:
 interface InterfaceD{
	 void method() throws ParseException, IOException;
 }
 

Compiler allows you to declare the common exception from within multiple interfaces. If the interfaces' exceptions are uncommon you will not be allowed to declare any checked exception.

I only wanted to figure this out.
Correct me if I am wrong.

[Deepak Bala]

That makes sense

For common exception hierarchies

InterfaceA - IOException
InterfaceB - FileNotFoundException
InterfaceC - ?

If InterfaceC is allowed to throw IOException then a statement like InterfaceB ref = new SubClassThatThrowsIOExAndImplementsC(); will get into trouble since the Exception scope does not allow this. IOException is wider than FileNotFoundException and the InterfaceB contract only allows you to throw FileNotFoundException

So InterfaceC can only throw FileNotFoundException

For the scenario

InterfaceA - IOException
InterfaceB - ParseException
InterfaceC - ?

InterfaceC is in trouble. For case

InterfaceB ref =  new SubClassThatThrowsIOExAndImplementsC();  // This is invalid. InterfaceB cannot catch IOException
InterfaceA ref =  new SubClassThatThrowsParseExAndImplementsC();  // This is invalid. InterfaceA cannot catch ParseException

So InterfaceC cannot throw anything, since the contract provided by InterfaceA or InterfaceB can be broken

Does that make sense ?