Basics of Java Programming 1
MODULE 4
Syllabus:
Packages: Packages, Access Protection, Importing Packages
Interfaces
Exception Handling: Exception-Handling Fundamentals, Exception Types, Uncaught Exceptions, Using try and
catch, Multiple catch Clauses, Nested try Statements, throw, throws, finally, Java’s Built-in Exceptions, Creating
Your Own Exception Subclasses, Chained Exceptions, Using Exceptions.
4.1 Packages
When we have more than one class in our program, usually we give unique names to classes. In a real-
time development, as the number of classes increases, giving unique meaningful name for each class will
be a problem. To avoid name-collision in such situations, Java provides a concept of packages. A
package is a collection of classes. 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.
4.1.1 Defining a Package
To create a package, include a package command as the first statement in a Java source file. Any class
declared within that file will belong to the specified package. If you omit the package statement, the class
names are put into the default package, which has no name.
General form of the package statement:
package pkg;
Example –
package MyPackage;
Java uses file system directories to store packages. For example, the .class file for any class 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 class in other files from being part of that same
package.
One 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. You cannot rename a package without renaming the directory in which the
classes are stored.
4.1.2 Finding Packages and CLASSPATH
As we have seen, packages are reflected with directories. This will raise the question that - how does
Java run-time know where to look for the packages that we create?
Dept of ISE, SCE
Basics of Java Programming 2
By default, Java run-time uses current working directory as a starting point. So, if our package
is in a sub-directory of current working directory, then it will be found.
We can set directory path using CLASSPATH environment variable.
We can use –classpath option with javac and java to specify path of our classes.
Assume that we have created a package MyPackage. When the second two options are used, the class
path must not include MyPackage. It must simply specify the path to MyPackage. For example, in a
Windows environment, if the path to MyPackage is
C:\MyPrograms\Java\MyPackage
Then the class path to MyPackage is
C:\MyPrograms\Java
Consider the program given below –
package MyPackage;
class Test
{
int a, b;
Test(int x, int y)
{
a=x; b=y;
}
void disp()
{
System.out.println("a= "+a+" b= "+b);
}
}
class PackDemo
{
public static void main(String args[])
{
Test t=new Test(2,3);
t.disp();
}
}
4.1.3 Access Protection
Java provides many levels of protection to allow fine-grained control over the visibility of variables and
methods within classes, subclasses, and packages. Classes and packages are both means of
encapsulating and containing the name space and scope of variables and methods. Packages act as
containers for classes and other subordinate packages. Classes act as containers for data and code. The
class is Java’s smallest unit of abstraction.
Java addresses four categories of visibility for class members:
Subclasses in the same package
Non-subclasses in the same package
Dept of ISE, SCE
Basics of Java Programming 3
Subclasses in different packages
Classes that are neither in the same package nor subclasses
Even a class has accessibility feature. A class can be kept as default or can be declared as public.
When a class is declared as public, it is accessible by any other code. If a class has default access, then
it can only be accessed by other code within its same package. When a class is public, it must be the
only public class declared in the file, and the file must have the same name as the class
Accessibility of members of the class can be better understood using the following table.
Private No Modifier Protected Public
Same class Yes Yes Yes Yes
Same package No Yes Yes Yes
subclass
Same package No Yes Yes Yes
non-subclass
Different package No No Yes Yes
Subclass
Different package No No No Yes
non-subclass
4.1.4 Importing Packages
Since classes within packages must be fully qualified with their package name or names, it could become
tedious to type in the long dot-separated package path name for every class you want to use. For this
reason, Java includes the import statement to bring certain classes, or entire packages, into visibility.
Once imported, a class can be referred to directly, using only its name.
In a Java source file, import statements occur immediately following the package statement (if it exists)
and before any class definitions. The general form of the import statement is:
import pkg1[.pkg2].(classname|*);
For example,
import java.util.Date;
import java.io.*;
The star form may increase compilation time—especially if you import several large packages. For this
reason it is a good idea to explicitly name the classes that you want to use rather than importing whole
packages. However, the star form has absolutely no effect on the run-time performance or size of your
classes.
All of the standard Java classes included with Java are stored in a package called java. The basic
language functions are stored in a package inside of the java package called java.lang. Normally, you
have to import every package or class that you want to use, but since Java is useless without much of the
functionality in java.lang, it is implicitly imported by the compiler for all programs. This is equivalent to the
following line being at the top of all of your programs:
Dept of ISE, SCE
Basics of Java Programming 4
import java.lang.*;
If a class with the same name exists in two different packages that you import using the star form, the
compiler will remain silent, unless you try to use one of the classes. In that case, you will get a compile-
time error and have to explicitly name the class specifying its package.
The import statement is optional. Any place you use a class name, you can use its fully qualified name,
which includes its full package hierarchy. For example,
import java.util.*;
class MyDate extends Date
{ ……………}
Can be written as –
class MyDate extends java.util.Date
{ …}
Dept of ISE, SCE
