Chapter 9:

Package and
Interface
Dr. Mohammad Rashedur Rahman
Defining a Package
A package is both a naming and a visibility control mechanism:
1) divides the name space into disjoint subsets It is possible to define classes
within a package that are not accessible by code outside the package.
2) controls the visibility of classes and their members It is possible to define
class members that are only exposed to other members of the same package.
Same-package classes may have an intimate knowledge of each other, but not
expose that knowledge to other packages
Creating a Package
• A package statement inserted as the first line of the source file:
package myPackage;
class MyClass1 { … }
class MyClass2 { … }
• means that all classes in this file belong to the myPackage package.
• The package statement creates a name space where such classes are stored.
• When the package statement is omitted, class names are put into the default
package which has no name.
Multiple Source Files
• Other files may include the same package instruction:
1. package myPackage;
class MyClass1 { … }
class MyClass2 { … }
2. package myPackage;
class MyClass3{ … }
• A package may be distributed through several source files
Packages and Directories
• Java uses file system directories to store packages.
• Consider the Java source file:
package myPackage;
class MyClass1 { … }
class MyClass2 { … }
• The byte code files MyClass1.class and MyClass2.class must be stored in a
directory myPackage.
• Case is significant! Directory names must match package names exactly.
Package Hierarchy
• To create a package hierarchy, separate each package name with a
dot:
package myPackage1.myPackage2.myPackage3;
• A package hierarchy must be stored accordingly in the file system:
1) Unix myPackage1/myPackage2/myPackage3
2) Windows myPackage1\myPackage2\myPackage3
3) Macintosh myPackage1:myPackage2:myPackage3
• You cannot rename a package without renaming its directory!
Accessing a Package
• As packages are stored in directories, how does the Java run-time system
know where to look for packages?
• Two ways:
1) The current directory is the default start point - if packages are stored in
the current directory or sub-directories, they will be found.
2) Specify a directory path or paths by setting the CLASSPATH environment
variable.
CLASSPATH Variable
• CLASSPATH - environment variable that points to the root directory of the
system’s package hierarchy.
• Several root directories may be specified in CLASSPATH,
• e.g. the current directory and the C:\User\myJava directory:
.;C:\User\myJava
• Java will search for the required packages by looking up subsequent directories
described in the CLASSPATH variable.
Finding Packages

• Consider this package statement:

package myPackage;
• In order for a program to find myPackage, one of the following must
be true:
1) program is executed from the directory immediately above
myPackage (the parent of myPackage directory)
2) CLASSPATH must be set to include the path to myPackage
Example: 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);
}
}
Example: Package
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();
}
}
Example: Package
• Save, compile and execute:
1) call the file AccountBalance.java
2) save the file in the directory MyPack
3) compile; AccountBalance.class should be also in MyPack
4) set access to MyPack in CLASSPATH variable, or make the parent of
MyPack your current directory
5) run: java MyPack.AccountBalance
• Make sure to use the package-qualified class name.
Importing of Packages

• Since classes within packages must be fully-qualified with their package

names, it would be tedious to always type long dot-separated names.
• The import statement allows to use classes or whole packages directly.
• Importing of a concrete class:
import myPackage1.myPackage2.myClass;
• Importing of all classes within a package:
import myPackage1.myPackage2.*;
Import Statement

• The import statement occurs immediately after the package statement and before the
class statement:
package myPackage;
• import otherPackage1;otherPackage2.otherClass;
class myClass { … }
• The Java system accepts this import statement by default:
import java.lang.*;
• This package includes the basic language functions. Without such functions, Java is of no
much use.
Example: Packages 1

• A package MyPack with one public class Balance.

The class has two same-package variables: public constructor and a public show method.
package MyPack;
public class Balance {
String name;
double bal;
public Balance(String n, double b) {
name = n; bal = b;
}
public void show() {
if (bal<0) System.out.print("-->> ");
System.out.println(name + ": $" + bal);
}
}
Example: Packages 2

The importing code has access to the public class Balance of the MyPack
package and its two public members:
import MyPack.*;
class TestBalance {
public static void main(String args[]) {
Balance test = new Balance("J. J. Jaspers", 99.88);
test.show();
}
}
Java Source File
• Finally, a Java source file consists of:
1) a single package instruction (optional)
2) several import statements (optional)
3) a single public class declaration (required)
4) several classes private to the package (optional)
• At the minimum, a file contains a single public class declaration.
Differences between classes and interfaces

• Interfaces are syntactically similar to classes, but they lack instance variables,
and their methods are declared without any body.
• One class can implement any number of interfaces.
• Interfaces are designed to support dynamic method resolution at run time.
More about interfaces

• Interface is little bit like a class... but interface is lack in instance variables....that's u can't
create object for it.....
• Interfaces are developed to support multiple inheritance...
• The methods present in interfaces are pure abstract..
• The access specifiers public,private,protected are possible with classes, but the interface
uses only one spcifier public.....
• interfaces contains only the method declarations.... no definitions.......
• A interface defines, which method a class has to implement. This is way - if you want to call
a method defined by an interface - you don't need to know the exact class type of an
object, you only need to know that it implements a specific interface.
• Another important point about interfaces is that a class can implement multiple interfaces.
Defining an interface

• Using interface, we specify what a class must do, but not how it does this.
• An interface is syntactically similar to a class, but it lacks instance
variables and its methods are declared without any body.
• An interface is defined with an interface keyword.
Defining an Interface
 An interface declaration consists of modifiers, the keyword interface, the interface name, a comma-
separated list of parent interfaces (if any), and the interface body. For example:
public interface GroupedInterface extends Interface1, Interface2, Interface3 {
// constant declarations double E = 2.718282;
// base of natural logarithms //
//method signatures
void doSomething (int i, double x);
int doSomethingElse(String s);
}
 The public access specifier indicates that the interface can be used by any class in any package. If you do not
specify that the interface is public, your interface will be accessible only to classes defined in the same package as
the interface.
 An interface can extend other interfaces, just as a class can extend or subclass another class. However, whereas a
class can extend only one other class, an interface can extend any number of interfaces. The interface declaration
includes a comma-separated list of all the interfaces that it extends
Implementing interface
• General format:
access interface name {
type method-name1(parameter-list);
type method-name2(parameter-list);
…
type var-name1 = value1;
type var-nameM = valueM;
…
}
Implementing interface (cont..)
• Two types of access:
1) public – interface may be used anywhere in a program
2) default – interface may be used in the current package only
• Interface methods have no bodies – they end with the semicolon after
the parameter list.
• They are essentially abstract methods.
• An interface may include variables, but they must be final, static and
initialized with a constant value.
• In a public interface, all members are implicitly public.
Interface Implementation
• A class implements an interface if it provides a complete set of methods
defined by this interface.
1) any number of classes may implement an interface
2) one class may implement any number of interfaces
• Each class is free to determine the details of its implementation.
• Implementation relation is written with the implements keyword.
Implementation Format

• General format of a class that includes the implements clause:

• Syntax:
access class name extends super-class implements interface1, interface2, …,
interfaceN {
…
}
• Access is public or default.
Implementation Comments
• If a class implements several interfaces, they are separated with a comma.
• If a class implements two interfaces that declare the same method, the
same method will be used by the clients of either interface.
• The methods that implement an interface must be declared public.
• The type signature of the implementing method must match exactly the
type signature specified in the interface definition.
Example: Interface
Declaration of the Callback interface:
interface Callback {
void callback(int param);
}
Client class implements the Callback interface:
class Client implements Callback {
public void callback(int p) {
System.out.println("callback called with " + p);
}
}
More Methods in Implementation

• An implementing class may also declare its own methods:

class Client implements Callback {
public void callback(int p) {
System.out.println("callback called with " + p);
}
void nonIfaceMeth() {
System.out.println("Classes that implement “ +
“interfaces may also define ” +
“other members, too.");
}
}
Accessing Implementations Through Interface
References
• You can declare variables as object references that use an interface rather
than a class type.
• Any instance of any class that implements the declared interface can be
referred to by such a variable.
• When you call a method through one of these references, the correct
version will be called based on the actual instance of the interface being
referred to.
• This is one of the key features of interfaces.
• The method to be executed is looked up dynamically at run time, allowing
classes to be created later than the code which calls methods on them.
Accessing Interfaces for different
implementations
Applying interfaces
A Java interface declares a set of method signatures i.e., says what behavior
exists Does not say how the behavior is implemented
i.e., does not give code for the methods
• Does not describe any state (but may include “final” constants)
A concrete class that implements an interface Contains
“implements InterfaceName” in the class declaration
Must provide implementations (either directly or
inherited from a superclass) of all methods declared in
the interface
An abstract class can also implement an interface
Can optionally have implementations of some or all
interface methods
• Interfaces and Extends both describe an “is- a”
relation
• If B implements interface A, then B inherits the
(abstract) method signatures in A
• If B extends class A, then B inherits everything in A,
• which can include method code and instance
variables as well as abstract method signatures
• Inheritance” is sometimes used to talk about the
superclass/subclass “extends” relation only
variables in interface
• Variables declared in an interface must be constants.
• A technique to import shared constants into multiple
classes:
1) declare an interface with variables initialized to the
desired values
2) include that interface in a class through
implementation
• As no methods are included in the interface, the class
does not implement anything except importing the
variables as constants.
Example: Interface Variables 1
An interface with constant values:
import java.util.Random;
interface SharedConstants {
int NO = 0;
int YES = 1;
int MAYBE = 2;
int LATER = 3;
int SOON = 4;
int NEVER = 5;
}
Example: Interface Variables 2
• Question implements SharedConstants, including all its
constants.
• Which constant is returned depends on the generated random
number:
class Question implements SharedConstants {
Random rand = new Random();
int ask() {
int prob = (int) (100 * rand.nextDouble());
if (prob < 30) return NO;
else if (prob < 60) return YES;
else if (prob < 75) return LATER;
else if (prob < 98) return SOON;
else return NEVER;
}
}
Example: Interface Variables 3
• AskMe includes all shared constants in the same way, using
them to display the result, depending on the value received:
class AskMe implements SharedConstants {
static void answer(int result) {
switch(result) {
case NO: System.out.println("No"); break;
case YES: System.out.println("Yes"); break;
case MAYBE: System.out.println("Maybe"); break;
case LATER: System.out.println("Later"); break;
case SOON: System.out.println("Soon"); break;
case NEVER: System.out.println("Never"); break;
}
}
Example: Interface Variables 4
The testing function relies on the fact that both ask
and answer methods,
defined in different classes, rely on the same
constants:
public static void main(String args[]) {
Question q = new Question();
answer(q.ask());
answer(q.ask());
answer(q.ask());
answer(q.ask());
}
}
extending interfaces
• One interface may inherit another interface.
• The inheritance syntax is the same for classes and
interfaces.
interface MyInterface1 {
void myMethod1(…) ;
}
interface MyInterface2 extends MyInterface1 {
void myMethod2(…) ;
}
• When a class implements an interface that inherits
another interface, it must provide implementations
for all methods defined within the interface
inheritance chain.
Example: Interface Inheritance 1
• Consider interfaces A and B.
interface A {
void meth1();
void meth2();
}

B extends A:
interface B extends A {
void meth3();
}
Example: Interface Inheritance 2
• MyClass must implement all of A and B methods:
class MyClass implements B {
public void meth1() {
System.out.println("Implement meth1().");
}
public void meth2() {
System.out.println("Implement meth2().");
}
public void meth3() {
System.out.println("Implement meth3().");
}}
Example: Interface Inheritance 3
• Create a new MyClass object, then invoke all interface
methods on it:
class IFExtend {
public static void main(String arg[]) {
MyClass ob = new MyClass();
ob.meth1();
ob.meth2();
ob.meth3();
}
}