In any Java source file first line after package
declarations are import statements. These
statements enable us to use different classes from outside package. Compiler
always looks at the import statements to find class definition.
Instead of import statements we can write fully qualified
name. For ex:
java.io. File file = new java.io.File(filepath);
This is a perfectly valid statement. Only problem is it looks littlie
complicated to read. Good codes are not
only run well but also easy to read.
So we will stick to
File file = new File(filepath);
To do so we have to write import statement at the beginning right
after the package declaration.
package mej.java.example;
import java.io.File;
If we use more than one classes or interface of java.io packages
we need to write multiple import statements.
package mej.java.example;
import java.io.File;
import java. FileInputStream;
or we can use wild characters like
java,io.*;
At first impression it looks simple, there are few side
effects with this. It takes down the performance of compiler, as compiler has
to look whole package for match. But it
doesn’t affect runtime performance of code in anyway. Many time developers
misunderstood it. There can be cases if
we use multiple wild character imports. And if both the package contains class
with same name, compiler will not able to resolve. And it also reduces the readability
of code. It’s difficult to read which class from which package is being used.
So the best way is to use import individually for each class or interface.
Another type of imports are static imports. To use it I can
say something like
import static java.lang.Match;
We can directly write
ceil(4.83) instead of Math.ceil(4.38).
By static imports we can directly use the methods or members instead of referring
through their class name. This is widely used in junit test cases to refer
Assert class methods.
In this case also too much use of static imports decrease
code maintainability.
Please let me know your thoughts about java imports.