JavaFAQ Home » Java Installation, tunning, options...
Multiple classes of larger programs are usually grouped together into a
package. Packages correspond to directories in the file system, and may be
nested just as directories are nested.
Using existing packages
Java libraries are organized in packages (directories). The most common way to
get access to them is to use the
import statement. For example,
. . .
ArrayList students; // ArrayList is a class in java.util
gives your program access to the all (that's what the "*" means) classes in the
java.util. The source files for these classes are in a
util, which is in a directory named
Importing classes explictly
If you need only one class from a package, eg
ArrayList, you can
. . .
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.
Using package qualifiers instead of imports
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
Because it's common to import all classes in both
java.swing, the name
Timer is ambiguous and can't be
used without qualification.
. . .
Timer t; //AMBIGUOUS - compilation error
java.util.Timer t; // OK
Packages within packages require additional imports
The import statment gives access to classes in a package, but not to packages
in that package. For example,
does not give access to the classes of the package
To access classes in
import is not the same as C++'s
#include is commonly used to for library headers, but the
mechanism which is used is fundamentally different.
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
Another difference is that Java imports are non-transitive. If class A
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++.
Printer Friendly Page
Send to a Friend
Search here again if you need more info!