Explain Packages In Java, Package Program In Java With Examples And Explanation
In This Topic & Blog Having Any Query Then Post your Comment and Suggestion Below
PackagesIn 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 only exposed
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.
183
184
Part I:
The Java Language
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
Chapter 9:
Packages and Interfaces
185
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
,orthe
CLASSPATH
must be
set to include the path to
MyPack
,orthe
-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];
186
Part I:
The Java Language
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.