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
. . .
ArrayList students; // ArrayList is a class in java.util
gives your program access to the all (that's what the "*" means) classes in
java.util. The source files for these classes are
in a directory named
util, which is in a directory named
Importing classes explictly
If you need only one class from a package, eg
. . .
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
java.swing.Timer. Because it's common to import all classes in both
java.swing, the name
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 source files).
Another difference is that Java imports are non-transitive. If class A
packagey, class A does NOT get access to
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++.
2699 bytes more | comments? | | Score: 0