Name conflict / package weirdness

Question

Hi all
I recently came across something weird that caused me a lot of grey hairs. Although I have worked around the problem, the explanation has got me stymied.
I have a package hierarchy that looks something like this:
zeeb.utils.db.DataAccessClass
zeeb.exceptions.CommunicationException
zeeb.objects.Good
zeeb.objects.Bad
zeeb.test.Good
zeeb.test.Bad
Note: to simplify things, I have renamed some of the classes and stripped out most of the methods. Each of the class definitions can be found below.
The class definitions for the 2 'Good' classes are identical - they simply sit in 2 different packages.
The same goes for the 2 'Bad' classes.
'Good' and 'Bad' are also almost identical - the only difference being in the syntax of their respective import statements:
Bad.java fragment
import zeeb.exceptions.*;Good.java fragment
import zeeb.exceptions.CommunicationException;As you can see, Good.java specifies CommunicationException 'explicitly', whilst Bad.java imports the entire package.
After I pop these files into the relevant folders and try and compile, this is what I get:
zeeb.objects.Good - compiles fine
zeeb.objects.Bad - compiles fine
zeeb.test.Good - compiles fine
zeeb.test.Bad - fails to compile
Here is the compilation error for zeeb.test.Bad:
Bad.java:13: exception zeeb.objects.CommunicationException is never thrown in body of corresponding try statement
                catch (CommunicationException ce) {
                ^
Bad.java:11: unreported exception zeeb.exceptions.CommunicationException; must be caught or declared to be thrown
                        dataAccess.executeUpdate();There are a couple of weird things here:
1. Firstly, why does zeeb.test.Bad fail to compile in the first place?
2. Secondly, if zeeb.test.Bad fails, why does zeeb.test.Good succeed? The only difference between the 2 classes is the idiom used for the import statement. But zeeb.exceptions.* expands to zeeb.exceptions.CommunicationException - so the 2 should be equivalent?
3. Lastly, if zeeb.test.Bad fails, why does zeeb.objects.Bad succeed? The 2 files are identical, the only difference being the package location.
Now here's the other funny thing. If I rename CommunicationException (and update the classes that reference it), the whole problem goes away. This got me thinking - perhaps there was another CommunicationException class somewhere in my CLASSPATH? I found one in rt.jar (javax.naming.CommunicationException) - so presumably that's the culprit here.
Still - there are some things here that don't add up. We have answered question '1' (above) - but questions '#2' and '#3' still stand. To reiterate the question (#2) again:
zeeb.exceptions.* expands to zeeb.exceptions.CommunicationException - so the 2 should be equivalent?
Can anyone enlighten me?
Many thanks
Pete
=============================
Class Definitions:
Bad.java (objects package)
package zeeb.objects;
import zeeb.utils.db.*;*
*import zeeb.exceptions.*;
public class Bad {
     public void foo() {
          DataAccessClass dataAccess = new DataAccessClass();
          try {     
               dataAccess.executeUpdate();               
          catch (CommunicationException ce) {
Bad.java (test package)
package zeeb.test;
import zeeb.utils.db.*;*
*import zeeb.exceptions.*;
public class Bad {
     public void foo() {
          DataAccessClass dataAccess = new DataAccessClass();
          try {     
               dataAccess.executeUpdate();               
          catch (CommunicationException ce) {
Good.java (objects package)
package zeeb.objects;
import zeeb.utils.db.*;
import zeeb.exceptions.CommunicationException;
public class Good {
     public void foo() {
          DataAccessClass dataAccess = new DataAccessClass();
          try {     
               dataAccess.executeUpdate();               
          catch (CommunicationException ce) {
Good.java (test package)
package zeeb.test;
import zeeb.utils.db.*;
import zeeb.exceptions.CommunicationException;
public class Good {
     public void foo() {
          DataAccessClass dataAccess = new DataAccessClass();
          try {     
               dataAccess.executeUpdate();               
          catch (CommunicationException ce) {
CommunicationException.java
package zeeb.exceptions;
public class CommunicationException extends Exception {
     public CommunicationException() {
     public CommunicationException(String message) {
          super(message);
DataAccessClass.java
package zeeb.utils.db;
import java.sql.*;*
*import java.util.*;
import zeeb.exceptions.*;
public class DataAccessClass {
     public DataAccessClass() {
     public void executeUpdate() throws CommunicationException {
          throw new CommunicationException();
}

Answer 1

pac wrote:
Here is the compilation error for zeeb.test.Bad:
Bad.java:13: exception zeeb.objects.CommunicationException is never thrown in body of corresponding try statement
catch (CommunicationException ce) {
^
Bad.java:11: unreported exception zeeb.exceptions.CommunicationException; must be caught or declared to be thrown
dataAccess.executeUpdate();...
2. Secondly, if zeeb.test.Bad fails, why does zeeb.test.Good succeed? The only difference between the 2 classes is the idiom used for the import statement. But zeeb.exceptions.* expands to zeeb.exceptions.CommunicationException - so the 2 should be equivalent?zeeb.exceptions.* doesn't "expand" to anything. It's just a shorthand convenience to make the compiler figure out what package a non-fully-qualified symbol reference belongs to.
Now here's the other funny thing. If I rename CommunicationException (and update the classes that reference it), the whole problem goes away. This got me thinking - perhaps there was another CommunicationException class somewhere in my CLASSPATH? I found one in rt.jar (javax.naming.CommunicationException) - so presumably that's the culprit here.
Not unless you imported javax.naming.*, which doesn't show in the (simplified) code snippets you posted.
I don't believe you have posted anything which truely represents the state of affairs which led to the compile error.