Packages
In the preceding chapters,
the name of each example class was taken from the same name space. This means
that a unique name had to be used for each class to avoid name collisions.
After a while, without some way to manage the name space, you could run out of
convenient, descriptive names for individual classes. You also need some way to
be assured that the name you choose for a class will be reasonably unique and
not collide with class names chosen by other programmers. (Imagine a small
group of programmers fighting over who gets to use the name “Foobar” as a class
name. Or, imagine the entire Internet community arguing over who first named a
class “Espresso.”) Thankfully, Java provides a mechanism for partitioning the
class name space into more manageable chunks. This mechanism is the package.
The package is both a naming and a visibility control mechanism. You can define
classes inside a package that are not accessible by code outside that package.
You can also define class members that are exposed only to other members of the
same package. This allows your classes to have intimate knowledge of each
other, but not expose that knowledge to the rest of the world.
Defining
a Package
To
create a package is quite easy: simply include a package command as the first statement in a Java source file. Any
classes declared within that file will belong to the specified package. The package statement defines a name space
in which classes are stored. If you omit the package statement, the class names are put into the default
package, which has no name. (This is
why you haven’t had to worry about packages before now.) While the default
package is fine for short, sample programs, it is inadequate for real
applications. Most of the time, you will define a package for your code.
This is the
general form of the package
statement: package pkg;
Here, pkg is the name of the package. For
example, the following statement creates a package called MyPackage:
package MyPackage;
Java uses file system
directories to store packages. For example, the .class files for any classes you declare to be part of MyPackage must be stored in a directory
called MyPackage. Remember that case
is significant, and the directory name must match the package name exactly.
More
than one file can include the same package
statement. The package statement
simply specifies to which package the classes defined in a file belong. It does
not exclude other classes in other files from being part of that same package.
Most real-world packages are spread across many files.
You can
create a hierarchy of packages. To do so, simply separate each package name
from the one above it by use of a period. The general form of a multileveled
package statement is shown here:
package pkg1[.pkg2[.pkg3]];
A
package hierarchy must be reflected in the file system of your Java development
system. For example, a package declared as
package java.awt.image;
needs to
be stored in java\awt\image in a
Windows environment. Be sure to choose your package names carefully. You cannot
rename a package without renaming the directory in which the classes are
stored.
Finding
Packages and CLASSPATH
As just explained, packages
are mirrored by directories. This raises an important question: How does the
Java run-time system know where to look for packages that you create? The
answer has three parts. First, by default, the Java run-time system uses the
current working directory as its starting point. Thus, if your package is in a
subdirectory of the current directory, it will be found. Second, you can
specify a directory path or paths by setting the CLASSPATH environmental variable. Third, you can use the -classpath option with java and javac to specify the path to your classes.
For example, consider the
following package specification:
package MyPack
In order
for a program to find MyPack, one of
three things must be true. Either the program can be executed from a directory
immediately above MyPack, or the CLASSPATH must be set to include the
path to MyPack, or the -classpath option must specify the path
to MyPack when the program is run
via java.
When the second two options
are used, the class path must not
include MyPack, itself. It must
simply specify the path to MyPack. For example, in a Windows
environment, if the path to MyPack
is
C:\MyPrograms\Java\MyPack
then the class path to MyPack is
C:\MyPrograms\Java
The easiest way to try the
examples shown in this book is to simply create the package directories below
your current development directory, put the .class files into the appropriate directories, and then execute the
programs from the development directory. This is the approach used in the
following example.
A
Short Package Example
Keeping the preceding
discussion in mind, you can try this simple package:
// A simple package
package
MyPack;
class Balance { String name;
double bal;
Balance(String n, double b) {
name = n;
bal = b;
}
void show() { if(bal<0)
System.out.print("-->
"); System.out.println(name + ": $" + bal);
}
}
class AccountBalance {
public static void
main(String args[]) { Balance current[] = new Balance[3];
current[0] = new Balance("K. J.
Fielding", 123.23); current[1] = new Balance("Will Tell",
157.02); current[2] = new Balance("Tom Jackson", -12.33);
for(int i=0; i<3; i++) current[i].show();
}
}
Call this file AccountBalance.java and put it in a
directory called MyPack.
Next, compile the file. Make
sure that the resulting .class file
is also in the MyPack directory.
Then, try executing the AccountBalance
class, using the following command line:
java MyPack.AccountBalance
Remember,
you will need to be in the directory above MyPack
when you execute this command. (Alternatively, you can use one of the other two
options described in the preceding section to specify the path MyPack.)
As
explained, AccountBalance is now
part of the package MyPack. This
means that it cannot be executed by itself. That is, you cannot use this
command line:
java AccountBalance
AccountBalance must be qualified with its package name.
Related Topics
Privacy Policy, Terms and Conditions, DMCA Policy and Compliant
Copyright © 2018-2023 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.