same package or in a separate package...

So to begin this chapter, you’ll
learn how library components are placed into packages. Then you’ll be
able to understand the complete meaning of the access specifiers. Feedback
package: the library unit
A package is what becomes available when you use the import keyword
to bring in an entire library, such as
import java.util.*;

This brings in the entire utility library that’s part of the standard Java
distribution. For instance, there’s a class called ArrayList in java.util,
so you can now either specify the full name java.util.ArrayList (which
you can do without the import statement), or you can simply say
ArrayList (because of the import). Feedback
If you want to bring in a single class, you can name that class in the
import statement
import java.util.ArrayList;

Now you can use ArrayList with no qualification. However, none of the
other classes in java.util are available. Feedback
The reason for all this importing is to provide a mechanism to manage
name spaces. The names of all your class members are insulated from
each other. A method f( ) inside a class A will not clash with an f( ) that has the same signature (argument list) in class B. But what about the class
names? Suppose you create a Stack class that is installed on a machine
which already has a Stack class that’s written by someone else? This
potential clashing of names is why it’s important to have complete control
232
Thinking in Java
www.BruceEckel.com

over the name spaces in Java, and to be able to create a completely unique
name regardless of the constraints of the Internet. Feedback
Most of the examples thus far in this book have existed in a single file and
have been designed for local use, so they haven’t bothered with package
names. (In this case the class name is placed in the “default package.”)
This is certainly an option, and for simplicity’s sake this approach will be
used whenever possible throughout the rest of this book. However, if
you’re planning to create libraries or programs that are friendly to other
Java programs on the same machine, you must think about preventing
class name clashes. Feedback
When you create a source-code file for Java, it’s commonly called a
compilation unit (sometimes a translation unit). Each compilation unit
must have a name ending in .java, and inside the compilation unit there
can be a public class that must have the same name as the file (including
capitalization, but excluding the .java filename extension). There can be
only one public class in each compilation unit, otherwise the compiler
will complain. If there are additional classes in that compilation unit, they
are hidden from the world outside that package because they’re not
public, and they comprise “support” classes for the main public class.
Feedback
When you compile a .java file you get an output file for each class in the
.java file. Each output file has the name of a class in the .java file, but with an extension of .class. Thus you can end up with quite a few .class
files from a small number of .java files. If you’ve programmed with a
compiled language, you might be used to the compiler spitting out an
intermediate form (usually an “obj” file) that is then packaged together
with others of its kind using a linker (to create an executable file) or a
librarian (to create a library). That’s not how Java works. A working
program is a bunch of .class files, which can be packaged and
compressed into a JAR file (using Java’s jar archiver). The Java
interpreter is responsible for finding, loading, and interpreting1 these
files. Feedback

1 There’s nothing in Java that forces the use of an interpreter. There exist native-code Java compilers that generate a single executable file.
Chapter 5: Hiding the Implementation
233

A library is a group of these class files. Each file has one class that is
public (you’re not forced to have a public class, but it’s typical), so
there’s one component for each file. If you want to say that all these
components (each in their own separate .java and .class files) belong
together, that’s where the package keyword comes in. Feedback
When you say:
package mypackage;

at the beginning of a file (if you use a package statement, it must appear as the first noncomment in the file), you’re stating that this compilation
unit is part of a library named mypackage. Or, put another way, you’re
saying that the public class name within this compilation unit is under
the umbrella of the name mypackage, and if anyone wants to use the
name they must either fully specify the name or use the import keyword
in combination with mypackage (using the choices given previously).
Note that the convention for Java package names is to use all lowercase
letters, even for intermediate words. Feedback
For example, suppose the name of the file is MyClass.java. This means
there can be one and only one public class in that file, and the name of
that class must be MyClass (including the capitalization):
package mypackage;