# Java Notes

# Packages - Importing

Packages = directories. Multiple classes of larger programs are grouped together into a package. Packages correspond to directories in the file system, and may be nested just as directories are nested. Small, single-class, programs typically do not use packages, but a

## Importing all classes from a package using *

Java libraries are organized in packages (directories). The most common way to get access to them is to use the `import` statement. For example,

    import java.util.*;
    . . .
    ArrayList<String> studentNames;  // ArrayList is a class in java.util

gives 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`.

## Importing each class explicitly

If you need only one class from a package, eg `ArrayList`, you can write

    import java.util.ArrayList;
    . . .
    ArrayList<String> studentNames;  // 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

The `import` statement is not required. Class references can be made but explicit qualification with the "." operator. For example,

    java.util.ArrayList<String> studentNames; // 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 `javax.swing`, the name `Timer` is ambiguous and can't be used without qualification.

    import java.util.*;    // The java.util package contains a Timer class.
    import javax.swing.*;  // The javax.swing package also contains a Timer class.
    . . .
    Timer t;            // AMBIGUOUS - compilation error
    java.util.Timer t;  // OK, you've told the compiler which one you want.

## Packages within packages require additional imports

The import statement 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.*;

## Java's `import` is not the same as C++'s `#include`

C++'s `#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++.