Naming Confliction

[Rajat Sarkar]

import static java.lang.System.out; /* imports static 'out' variable */
import static java.lang.Math.*; /* imports all the static methods of 'Math' class */

public class ImportStatic
{
public static void main(String[] args)
{
out.println("sqrt "+sqrt(2.0));
out.println("tan "+tan(60));
}
}


while we import 'static' members, is there any possibility of naming confliction?
If there any,then how the compiler resolves it?

[Steve Luke]

Naming conflicts can happen with static imports. They occur in two basic scenarios:

1) When staticly importing 'all' statics from multiple classes

import static statics.StaticSource1.*; //has a static member called 'doStuff()'
import static statics.StaticSource2.*; //has a static member called 'doStuff()'

public class StaticImporter
{
   public static void main(String[] args)
   {
      doStuff(); //compile time error here: "doStuff() is ambiguous"
    }
}

2) When staticly importing a method with the same name from multiple classes.

import static statics.StaticSource1.doStuff;
import static statics.StaticSource2.doStuff;

public class StaticImporter
{
   public static void main(String[] args)
   {
      doStuff(); //compile time error here: "doStuff() is ambiguous"
    }
}

The compiler does not resolve the issue (which is why there is a conflict) so you have to. The solutions are as follows:
1) If the conflict came about because of using a wildcard to import static content from multiple classes, add a new static import line for the conflicted name you want to use.
Example:

import static statics.StaticSource1.doStuff; //Disambiguate doStuff() call.  Must be before the .* import for the class...
import static statics.StaticSource1.*; //has a static member called 'doStuff()'
import static statics.StaticSource2.*; //has a static member called 'doStuff()'

public class StaticImporter
{
   public static void main(String[] args)
   {
      doStuff(); //will call StaticSource1's implementation
    }
}

2) Specify at the point of the call which implementation of the conflicted member you want to use (especially useful if you want to use one implementation in 1 line, and the other implementation in another line:

import static statics.StaticSource1.*; //has a static member called 'doStuff()'
import static statics.StaticSource2.*; //has a static member called 'doStuff()'

public class StaticImporter
{
   public static void main(String[] args)
   {
      statics.StaticSource1.doStuff(); //Disambiguates the doStuff() call
    }
}

My feeling, though, is that if you have to worry about naming conflicts when using static imports you are probably over-using static imports. They are something I would suggest using sparingly, as they will probably cause headaches later on (now where did this value come from? Where is that method declared? etc...)