import
statement.
For example,
import java.util.*; . . . ArrayList students; // ArrayList is a class in java.utilgives your program access to the all (that's what the "*" means) classes in the package
java.util
.
The source files for these classes are in a directory named
util
, which is in a directory named java
.
If you need only one class from a package, eg ArrayList
, you can write
import java.util.ArrayList; . . . ArrayList students; // same as above.
You might think that importing all classes from a package is inefficient, but there is no noticeable difference in my experience. Consequently most programs use the ".*" style of import.
import
statement is not required.
Class references can be made but explicit qualification with the "."
operator. For example,
java.util.ArrayList students; // fully qualified. No need for import.
The fully qualified style is used in some textbooks, but is generally not used when programming, where the import style is almost universal.
However, there is one situation where qualification is
necessary - when two classes have the same name,
but are in different packages. For example, there is both
java.util.Timer
and java.swing.Timer
.
Because it's common to import all classes in both java.util
and java.swing
, the name Timer
is ambiguous and
can't be used without qualification.
import java.util.*; import java.swing.*; . . . Timer t; //AMBIGUOUS - compilation error java.util.Timer t; // OK
The import statment gives access to classes in a package, but not to packages in that package. For example,
import java.util.*;does not give access to the classes of the package
java.util.regex
.
To access classes in java.util
and
java.util.regex
, import both.
import java.util.*; import java.util.regex.*;
import
is not the same as C++'s #include
#include
is commonly used to for library headers,
but the mechanism which is used is fundamentally different.
#include
inserts the entire source file that is referenced into
your C++ program.
In contrast, the Java import
statement only looks up the
the identifiers and their declarations from the compiled class file (not the
source files).
Another difference is that Java imports are non-transitive.
If class A imports packagex
and packagex
imports packagey
, class A does NOT get access to packagey
.
In C++, the imports are transitive, which can lead to some unexpected effects.
A minor difference is that Java's import
is a statement and
requires a semicolon, unlike C++.