Java Language problem: Multiple interfaces extension.

Question

Not just any interfaces. Take a close look:
public interface interface1 {
     public void aMethod();
public interface Interface2 {
     public void aMethod() throws Exception();
}As you can see, both interfaces define a single method with the same signature... but one of them throws Exception.
Consider "merging" these two interfaces:
public interface Interface3 extends Interface1, Interface2 {}Should the resulting method throw Exception? Eclipse says it does. But I think it shouldn't. Here's the logic:
If the method in Interface3 DIDN'T throw Exception, it would be able to extends the method in Interface1 and Interface2, because it is not throwing checked exceptions not thrown in the superinterfaces' methods definitions... however, as It DOES throw Exception, it can't extend the method in Interface1, because Interface1's method doesn't throw Exception. Am I right?

Answer 1

It's not a naming problem. I'll tell you where the problem comes from:
I'm working with EJBs. I (personally) like to separete the business "signatures" of the beans in a single interface.
So, for every bean I make, I have a single interface that defines the method.... it says NOTHING about the beans.
Remote beans methods have to throw RemoteException, so I have to throw RemoteException in my business logic classes. I then make two interfaces that implement this interface. One remote (that just extends this interface and EJBRemote) and another local that extends EJBLocal and overrides all the methods so they don't throw RemoteExceptions (Local bean interfaces' methods must NOT throw RemoteException).
For example:
public interface Beaninterface {
public void aMethod() throws RemoteExeption();
public interface Bean extends EJBRemote, BeanInterface {}
public interface BeanLocal extends EJBLocalObject , Beaninterface {
public void aMethod();
}No problem so far.
Here's where the mess comences:
I want to EXTEND this bean interfaces so I make a bean based on the former.
I will add another method to the business interface of the new bean:
Business Interface
public interface ExtendedBeanInterface extends BeanInterface {
public void newMethod() throws RemoteException;
}This new interface defines the new method and inherits the method from BeanInterface
Remote Interface of the new bean:
public interface ExtendedBean extends ExtendedBeanInterface, EJBObject {}Nothing wo do there.
Here is the real problem:
I have to extend the ExtendedBeanInterface, but that will bring two methods that throw Remote Exception. I have no problem overriding both methods in this interface.. but how about if thyere are 50 methods in the BeanInterface? I'm not going to go ahead and removing each method for evety bean I extend. That makes NO sense. What I think I should do is to extend BeanLocal so those methods that were brought from BeanInterface be known not to throw RemoteExeption.
public interface ExtendedBeanLocal extends EJBLocalObject, ExtendedBeanInterface, BeanLocal {
public void newMethod();
}And THERE is where I hit the wall, because when I deploy the bean, the application server informs me that the resulting interface is throwing RemoteException (courtesy of ExtendedBeanInterface).
Accoring to my logic about Java Language, by extending BeanLocal, aMethod() shouldn't throw RemoteException as a result in ExtendedBeanLocal.
So... what is the next step? Go with JCP?