What does the "static" modifier after "import" mean?
JavaModifierStatic ImportJava Problem Overview
When used like this:
import static com.showboy.Myclass;
public class Anotherclass{}
what's the difference between import static com.showboy.Myclass
and import com.showboy.Myclass
?
Java Solutions
Solution 1 - Java
See Documentation
> The static import declaration is > analogous to the normal import > declaration. Where the normal import > declaration imports classes from > packages, allowing them to be used > without package qualification, the > static import declaration imports > static members from classes, allowing > them to be used without class > qualification. > > So when should you use static import? > Very sparingly! Only use it when you'd > otherwise be tempted to declare local > copies of constants, or to abuse > inheritance (the Constant Interface > Antipattern). In other words, use it > when you require frequent access to > static members from one or two > classes. If you overuse the static > import feature, it can make your > program unreadable and unmaintainable, > polluting its namespace with all the > static members you import. Readers of > your code (including you, a few months > after you wrote it) will not know > which class a static member comes > from. Importing all of the static > members from a class can be > particularly harmful to readability; > if you need only one or two members, > import them individually. Used > appropriately, static import can make > your program more readable, by > removing the boilerplate of repetition > of class names.
Solution 2 - Java
There is no difference between those two imports you state. You can, however, use the static import to allow unqualified access to static members of other classes. Where I used to have to do this:
import org.apache.commons.lang.StringUtils;
.
.
.
if (StringUtils.isBlank(aString)) {
.
.
.
I can do this:
import static org.apache.commons.lang.StringUtils.isBlank;
.
.
.
if (isBlank(aString)) {
.
.
.
You can see more in the documentation.
Solution 3 - Java
Static import is used to import static fields / method of a class instead of:
package test;
import org.example.Foo;
class A {
B b = Foo.B_INSTANCE;
}
You can write :
package test;
import static org.example.Foo.B_INSTANCE;
class A {
B b = B_INSTANCE;
}
It is useful if you are often used a constant from another class in your code and if the static import is not ambiguous.
Btw, in your example "import static org.example.Myclass;" won't work : import is for class, import static is for static members of a class.
Solution 4 - Java
The basic idea of static import is that whenever you are using a static class,a static variable or an enum,you can import them and save yourself from some typing.
I will elaborate my point with example.
import java.lang.Math;
class WithoutStaticImports {
public static void main(String [] args) {
System.out.println("round " + Math.round(1032.897));
System.out.println("min " + Math.min(60,102));
}
}
Same code, with static imports:
import static java.lang.System.out;
import static java.lang.Math.*;
class WithStaticImports {
public static void main(String [] args) {
out.println("round " + round(1032.897));
out.println("min " + min(60,102));
}
}
Note: static import can make your code confusing to read.
Solution 5 - Java
> the difference between "import static com.showboy.Myclass" and "import com.showboy.Myclass"?
The first should generate a compiler error since the static import only works for importing fields or member types. (assuming MyClass is not an inner class or member from showboy)
I think you meant
import static com.showboy.MyClass.*;
which makes all static fields and members from MyClass available in the actual compilation unit without having to qualify them... as explained above
Solution 6 - Java
The import
allows the java programmer to access classes of a package without package qualification.
The static import
feature allows to access the static members of a class without the class qualification.
The import
provides accessibility to classes and interface whereas static import
provides accessibility to static members of the class.
Example :
With import
import java.lang.System.*;
class StaticImportExample{
public static void main(String args[]){
System.out.println("Hello");
System.out.println("Java");
}
}
With static import
import static java.lang.System.*;
class StaticImportExample{
public static void main(String args[]){
out.println("Hello");//Now no need of System.out
out.println("Java");
}
}
See also : What is static import in Java 5
Solution 7 - Java
Say you have static fields and methods inside a class called MyClass
inside a package called myPackage
and you want to access them directly by typing myStaticField
or myStaticMethod
without typing each time MyClass.myStaticField
or MyClass.myStaticMethod
.
Note : you need to do an
import myPackage.MyClass
or myPackage.*
for accessing the other resources
Solution 8 - Java
The static
modifier after import
is for retrieving/using static fields of a class. One area in which I use import static
is for retrieving constants from a class.
We can also apply import static
on static methods. Make sure to type import static
because static import
is wrong.
What is static import
in Java - JavaRevisited - A very good resource to know more about import static
.
Solution 9 - Java
Very good exaple. npt tipical with MAth in wwww....
https://www.java2novice.com/java-fundamentals/static-import/
public class MyStaticMembClass {
public static final int INCREMENT = 2;
public static int incrementNumber(int number){
return number+INCREMENT;
}
}
in onother file inlude
import static com.java2novice.stat.imp.pac1.MyStaticMembClass.*;