Chapter9

Packages and Interfaces

Lecture 6
 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:\raju\myJava directory:
.;C:\raju\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.
• 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.
Sr. No. Key Class Interface

Supported Methods A class can have both an abstract as well Interface can have only abstract methods. Java 8
1 as concrete methods. onwards, it can have default as well as static
methods.

2 Multiple Inheritance Multiple Inheritance is not supported. Interface supports Multiple Inheritance.

Supported Variables final, non-final, static and non-static Only static and final variables are permitted.
3
variables supported.

Implementation A class can implement an interface. Interface can not implement an interface, it can
4
extend an interface.

5 Keyword A class is declared using class keyword. Interface is declared using interface keyword.

Inheritance A class can inherit another class using Interface can inherit only an interface.
6 extends keyword and implement an
interface.

Inheritance A class can be inherited using extends Interface can only be implemented using
7
keyword. implements keyword.

Access A class can have any type of members like Interface can only have public members.
8
private, public.

9 Constructor A class can have constructor methods. Interface can not have a constructor.
 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;
…
}
• 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.");
}
}
 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();
}
}
 Package java.io
• Provides for system input and output through data streams,
serialization and the file system.
Interface Summary
• .DataInput The DataInput interface provides for reading bytes
from a binary stream and reconstructing from them data in
any of the Java primitive types.
• DataOutputThe DataOutput interface provides for converting
data from any of the Java primitive types to a series of bytes
and writing these bytes to a binary stream
• .Externalizable Only the identity of the class of an
Externalizable instance is written in the serialization stream
and it is the responsibility of the class to save and restore the
contents of its instances.
• SerializableSerializability of a class is enabled by the class
implementing the java.io.Serializable interface.
 Class Summary
• BufferedInputStream: A BufferedInputStream adds functionality to
another input stream-namely, the ability to buffer the input and to
support the mark and reset methods.
• BufferedOutputStream: The class implements a buffered output
stream.
• BufferedReader: Reads text from a character-input stream, buffering
characters so as to provide for the efficient reading of characters,
arrays, and lines.
• BufferedWriter: Writes text to a character-output stream, buffering
characters so as to provide for the efficient writing of single characters,
arrays, and strings
• ByteArrayInputStream: A ByteArrayInputStream contains an internal
buffer that contains bytes that may be read from the stream.
• ByteArrayOutputStream: This class implements an output stream in
which the data is written into a byte array.
• CharArrayReader: This class implements a
character buffer that can be used as a character-
input stream
• .CharArrayWriter: This class implements a
character buffer that can be used as an Writer
• Console: Methods to access the character-based
console device, if any, associated with the current
Java virtual machine.
• DataInputStream: A data input stream lets an
application read primitive Java data types from an
underlying input stream in a machine-
independent way.
• DataOutputStream: A data output stream lets an
application write primitive Java data types to an
output stream in a portable way.
• File: An abstract representation of file and directory pathnames.
• FileInputStream: A FileInputStream obtains input bytes from a file in a
file system.
• FileOutputStream: A file output stream is an output stream for writing
data to a File or to a FileDescriptor.
• FileReader: Convenience class for reading character files.
• FileWriter: Convenience class for writing character files.
• FilterInputStream: A FilterInputStream contains some other input
stream, which it uses as its basic source of data, possibly transforming
the data along the way or providing additional functionality.
• FilterOutputStream: This class is the superclass of all classes that filter
output streams
• .FilterReader: Abstract class for reading filtered character streams
• .FilterWriter: Abstract class for writing filtered character streams
• .InputStream: This abstract class is the superclass of all classes
representing an input stream of bytes.
• InputStreamReader: An InputStreamReader is a bridge from byte
streams to character streams: It reads bytes and decodes them into
characters using a specified charset.
• ObjectInputStream: An ObjectInputStream deserializes primitive data
and objects previously written using an ObjectOutputStream
• ObjectOutputStream: An ObjectOutputStream writes primitive data
types and graphs of Java objects to an OutputStream.
• OutputStream: This abstract class is the superclass of all classes
representing an output stream of bytes.
• OutputStreamWriter: An OutputStreamWriter is a bridge from
character streams to byte streams: Characters written to it are
encoded into bytes using a specified charset.
• PrintWriter: Prints formatted representations of objects to a text-
output stream.
• RandomAccessFile: Instances of this class support both reading and
writing to a random access file.
• StreamTokenizer: The StreamTokenizer class takes an input stream and
parses it into "tokens", allowing the tokens to be read one at a time.
 Exception Summary
• FileNotFoundException: Signals that an attempt
to open the file denoted by a specified pathname
has failed.
• InterruptedIOException: Signals that an I/O
operation has been interrupted
• InvalidClassException: Thrown when the
Serialization runtime detects one of the following
problems with a Class.
• InvalidObjectException: Indicates that one or
more deserialized objects failed validation tests.
• IOException: Signals that an I/O exception of
some sort has occurred.
 Package java.util

• Contains the collections framework, legacy

collection classes, event model, date and time
facilities, internationalization, and
miscellaneous utility classes (a string
tokenizer, a random-number generator, and a
bit array).
 Interface Summary
• Collection<E>: The root interface in the collection hierarchy.
• Comparator<T>: A comparison function, which imposes a
total ordering on some collection of objects.
• Enumeration<E>: An object that implements the Enumeration
interface generates a series of elements, one at a time.
• EventListener: A tagging interface that all event listener
interfaces must extend.
• Iterator<E>: An iterator over a collection
• List<E>An ordered collection (also known as a sequence).
• ListIterator<E>: An iterator for lists that allows the
programmer to traverse the list in either direction, modify the
list during iteration, and obtain the iterator's current position
in the list.
• Map<K,V>: An object that maps keys to values.
• Observer: A class can implement the Observer
interface when it wants to be informed of
changes in observable objects.
• Queue<E>: A collection designed for holding
elements prior to processing.
• Set<E>: A collection that contains no duplicate
elements.
• SortedMap<K,V>: A Map that further provides a
total ordering on its keys.
• SortedSet<E>: A Set that further provides a total
ordering on its elements.
 Class Summary
• AbstractCollection<E>: This class provides a skeletal implementation of
the Collection interface, to minimize the effort required to implement
this interface.
• AbstractList<E>: This class provides a skeletal implementation of the
List interface to minimize the effort required to implement this
interface backed by a "random access" data store (such as an array).
• AbstractMap<K,V>: This class provides a skeletal implementation of
the Map interface, to minimize the effort required to implement this
interface.
• AbstractQueue<E>: This class provides skeletal implementations of
some Queue operations.
• AbstractSequentialList<E>: This class provides a skeletal
implementation of the List interface to minimize the effort required to
implement this interface backed by a "sequential access" data store
(such as a linked list).
• AbstractSet<E>: This class provides a skeletal implementation of the
Set interface to minimize the effort required to implement this
interface.
 ArrayList<E>: Resizable-array implementation of the
List interface
 Arrays: This class contains various methods for
manipulating arrays (such as sorting and searching).
 BitSet: This class implements a vector of bits that
grows as needed
 Calendar: The Calendar class is an abstract class that
provides methods for converting between a specific
instant in time and a set of calendar fields: such as
YEAR, MONTH, DAY_OF_MONTH, HOUR, and so on,
and for manipulating the calendar fields, such as
getting the date of the next week
• Collections: This class consists exclusively of static
methods that operate on or return collections
• Currency: Represents a currency.
• Date: The class Date represents a specific instant in
time, with millisecond precision.
• Dictionary<K,V>: The Dictionary class is the abstract
parent of any class, such as Hashtable, which maps
keys to values.
• EventObject: The root class from which all event
state objects shall be derived.
• GregorianCalendar: GregorianCalendar is a concrete subclass of
Calendar and provides the standard calendar system used by most of
the world.
• HashMap<K,V>: Hash table based implementation of the Map
interface.
• HashSet<E>: This class implements the Set interface, backed by a hash
table (actually a HashMap instance)
• .Hashtable<K,V>: This class implements a hashtable, which maps keys
to values.
• LinkedList<E>: Linked list implementation of the List interface
• Locale: A Locale object represents a specific geographical, political, or
cultural region.
• Observable: This class represents an observable object, or "data" in
the model-view paradigm
• Properties: The Properties class represents a persistent set of
properties.
• Random: An instance of this class is used to generate a stream of
pseudorandom numbers.
• ResourceBundle: Resource bundles contain locale-specific objects.
• SimpleTimeZone: SimpleTimeZone is a concrete subclass of TimeZone
that represents a time zone for use with a Gregorian calendar.
• Stack<E>: The Stack class represents a last-in-first-out (LIFO) stack of
objects.
• StringTokenizer: The string tokenizer class allows an application to
break a string into tokens.
• TimeZone: TimeZone represents a time zone offset, and also figures
out daylight savings.
• TreeMap<K,V>: A Red-Black tree based NavigableMap
implementation.
• TreeSet<E>: A NavigableSet implementation based on a
TreeMap.UUIDA class that represents an immutable universally unique
identifier (UUID).
• Vector<E>: The Vector class implements a growable array of objects
 Exception Summary
• EmptyStackException: Thrown by methods in the Stack class to
indicate that the stack is empty.
• InputMismatchException: Thrown by a Scanner to indicate that the
token retrieved does not match the pattern for the expected type, or
that the token is out of range for the expected type.
• InvalidPropertiesFormatException: Thrown to indicate that an
operation could not complete because the input did not conform to
the appropriate XML document type for a collection of properties, as
per the Properties specification.
• NoSuchElementException: Thrown by the nextElement method of an
Enumeration to indicate that there are no more elements in the
enumeration.
• TooManyListenersException: The TooManyListenersException
Exception is used as part of the Java Event model to annotate and
implement a unicast special case of a multicast Event Source.
• UnknownFormatConversionException: Unchecked exception thrown
when an unknown conversion is given.