UNIT -IV

INHERITANCE, PACKAGES
AND INTERFACES
TOPIC TO BE COVERED…..
4.1Basics of Inheritance:
 Types of inheritance
 concepts of method overriding,
 extending class, super class, subclass,
 dynamic method dispatch & Object class
4.2 Creating package, importing package, access
rules for packages, class hiding rules in a
package
4.3Defining interface, inheritance on interfaces,
implementing interface, multiple inheritance
using interface
4.4 Abstract class and final class
INHERITANCE
 It is process by which objects of one class can use
properties of objects of another class.
 The mechanism of deriving a new class from old
class is called inheritance.

Data Data

methods methods

object object

class A class B
INHERITANCE
 Inheritance provides reusability of code.
 Java class can be reused in several ways by creating
new class.
 Reusing the properties of existing class called
inheritance.
 Old class is also known as
 Base class
 Super class
 Parent class
 New class is also known as
 Derived class
 Sub class
 Child class
INHERITANCE
 Inheritance allows subclasses to inherit all variable
and methods of their parent class.
 Object have no super class.
Types of inheritance :
1) Single inheritance (only one super class)
2) Hierarchical inheritance(1 super class, many
subclasses)
3) Multilevel inheritance (derived from a derived
class)
4) Multiple inheritance(several super class)
5) Hybrid inheritance(more than one super and sub
class)
[ Java does not directly support multiple inheritance
which is actually supported in c ++, but it is
implemented using interface.]
Syntax for defining a subclass:

class subclassname extends superclassname

{
Variable section;
method section;
}

Extends :it is keyword.

it signifies that properties of superclassname
are extended to the subclassname
INHERITANCE
 So, subclass will now contain its own variables
and methods as well as those of super class.
 It occurs when we want to add some more
properties to an existing class without actually
modifying it.
 Sub class can use the members of super class but
super class can not access subclass’s members.
SINGLE INHERITANCE
 Only one super class
 Every class has one and only one direct superclass.

 If class inherits only a single class ,is called single

inheritance.

class A
{ A
---------
---------
}
class B extends A B
{
--------- Single inheritance
---------
}
EXAMPLE
class A //super class
{
int i;
}
class B extends A //sub class
{
void display()
{
System.out.println("i="+i);
}
}
EXAMPLE
class Single
{
public static void main(String args[])
{
B b1=new B();
b1.i=7;
b1.display();
}
}

Output:
i=7
MULTI LEVEL INHERITANCE
 New class is derived from derived class.
 Java uses mainly in building its class library

Class C members
A Super class
Class B members
Class A members
B Intermediate super class

C Sub class

Multilevel inheritance
 class A
{
---------
---------
}
class B extends A
{
---------
---------
}
class C extends B
{
---------
---------
}
Here class C can use properties of class B and class B uses the
properties of class A. So class C can use properties of A and B.
HIERARCHICAL INHERITANCE
 one super class, many subclasses.
 Many classes extends one sub class

 Many programming problems can be featured of one

level shared by other below level

B C D

Multilevel inheritance
class A
{
---------
}
class B extends A
{
---------
}
class C extends A
{
---------
}
Class D extends A
{
---------
}
Here, class A extended by class B ,C, D.
MULTIPLE INHERITANCE
 One class extends properties of Several super classes.
 Java does not support this directly.

A B

multiple inheritance

 Here class C uses properties of class A and class

B at same level.
class A
{
---------
---------
}
Class C extends A
{
---------
---------
}
Class C extends B
{
---------
---------
}
Here class C can use properties of class A and class B.but A and B
can not use properties of C.
HYBRID INHERITANCE
 We can inherit properties of several classes at same
level. If you are using only classes then this is not
allowed in java, but using interfaces it is possible to
have implement hybrid inheritance in java.
EXAMPLE
interface A
{
public void methodA();
}
interface B extends A
{
public void methodB();
}
interface C extends A
{
public void methodC();
}
EXAMPLE
class D implements B, C
{
public void methodA()
{
System.out.println("MethodA");
}
public void methodB()
{
System.out.println("MethodB");
}
public void methodC()
{
System.out.println("MethodC"); }}
EXAMPLE

class HybridDemo
{
public static void main(String args[])
{
D obj1= new D();
obj1.methodA();
obj1.methodB();
obj1.methodC();
}
}
NESTING METHODS
 A method can be called by using only its name by
another method of same class, is nesting of methods.
class Nesting
{ int m,n;
Nesting(int x , int y)
{ m=x; n=y;
}
int largest ( )
{ if( m >= n)
return(m);
else
return(n);
}
EXAMPLE
void display ( )
{
int large=largest ( ); //calling a method
System .out. println (“large value”+large);
}}
class Nest_test
{
public static void main(String args[ ])
{
Nesting n=new Nesting ( 50 , 40 );
n .display ( );
}
} output : 50
 SUB CLASS CONSTRUCTOR
 Constructor which is defined in subclass is called sub
class constructor.
 It is used to create instance variable of both sub class
and super class.
 super keyword is used.

 We can use super in two ways:

 super is used to invoke constructor method of super

class.
 super is used to access variable of super class which
have same name as in sub class.
CONDITION TO USE SUPER
1. super may only be used with in sub class
constructor method.
2. Call to super class constructor must appear as
first statement sub class constructor.
3. The parameter in super call must match the
order and type of instance variable declared in
super class.

Constructor in derived class use super to pass

values that are required by base constructor.
EXAMPLE
class Room //super class
{
int length;
int width;
Room ( int x , int y) //super class constructor
{
length=x;
width=y;
}
int area ( )
{
return ( length * width ) ;
}}}
EXAMPLE
class BedRoom extends Room //sub class
{ int height;
BedRoom( int x ,int y, int z) //sub class
constructor
{
super( x , y); // pass values to
super class
height=z;
}
int volume ( )
{
return ( length * width * height );
}}
EXAMPLE
class Inheritance
{
public static void main ( String args[ ])
{
BedRoom room1=new BedRoom ( 10 , 10 , 12);
int area1=room1.area ( ); //super class method
int vol =room1.volume( ); //sub class method

System .out .println (“area1=” + area1);

System .out. println (“vol=” + vol);
}
}
 ACCESS VARIABLE OF SUPER CLASS
HAVING SAME NAME
class A
{ int i ; }

class B extends A
{ int i;
B ( int a , int b)
{ super . i =a;
i =b; }
void show( )
{
System . out .println ( “i in super =“ +super .i ) ;
System . out .println( “i in sub =“ +i); }
}
EXAMPLE
class SuperDemo
{
public static void main ( String args[ ])
{
B subob= new B( 1, 2);
subob . show();
}
}
Output:
i in super=1
i in sub=2
METHOD OVERRIDING
(FUNCTION OVERRIDING)
 Methods defined in super class is inherited and used
by objects of the subclass .
 If we want an object to respond to same method but
having different behavior when method is called .
 It is possible by defining a method in sub class ,that
has same name , same arguments, same return
type as in method in the super class.
 When method in super class is called ,the method
define in subclass is invoked and executed instead of
one in super class this is called overriding of method.
METHOD OVERRIDING
(FUNCTION OVERRIDING)
 When same method name , same argument &
same return type) is used in sub class and super
class ,is called method overriding.
 We can overload methods in same class.
 In this case, Method in sub class overrides the
method in super class.

Note:
1. Method overloading can be done in same
class.
2. Method overriding can be done in different
class. when super class and subclass are used(
when inheritance is used).
EXAMPLE
class SuperClass
{
void display( )
{
System .out .println ( “ Super Class”);
}

void show( int x)

{
System. out .println (“ x in super class=“+x);
}
}
EXAMPLE
class SubClass extends SuperClass
{
void display( ) //method same as in super
class
{
System .out .println ( “ Sub Class”);
}
void show( int x) //method same as in super
class
{
System. out .println (“ x in sub class =“+x);
}
}
EXAMPLE
class MethodOverRide
{
public static void main(String args[])
{
SubClass subo = new SubClass( );
subo . display();
subo . display();
subo .show(5);
//SuperClass supero =new SuperClass();
//Supero . display();
//Supero . show(10);
}}
Output :

Sub class
Sub class
x in sub class= 5
EXAMPLE 2:
class Super
{
int x;
Super (int x)
{
this.x =x;
}
void display( )
{
System .out .println (“super x=“+x);
}
}
class Sub extends Super
{
int y=10;
Sub (int x ,int y)
{ super( x);
this . y =y; // if put this statement in comment
line, y has value 10.
}
void display( )
{
System .out .println (“super x=“+x);
System .out .println (“sub y=“+y);
}
}
class Override
{
public static void main(String args[])
{
Sub s1=new Sub(100,200);
s1.display();
}
}
 ABSTRACT CLASS AND METHODS
 final makes any method protected means it cant be
extended. Java also allow us to exactly opposite to above
one.
 If we want method must always be redefined in subclass
,to make overriding compulsory.
 Then abstract (modifier) keyword is used to make
overriding compulsory.
 abstract can be used with class and methods.

 Ex: abstract class Shape

{ ------------

abstract void draw( );

-----------
----------- }
ABSTRACT CLASS AND METHODS
 abstract method are referred as sub classer
responsibility because they have no implementation
specified in the super class.
 Subclass must override them ,it can not simply use
the version defined in super class.
 Method in super class does not have body.

Syntax: abstract type name (parameter-list) ;

 if a class contains one or more abstract methods , it
should be declared as abstract class.
 Any subclass of an abstract class must either
implement all of the abstract methods in the super
class, or be itself declared abstract.
ABSTRACT CLASS AND METHODS
 Abstract class have both abstract (without body) and
concrete methods(normal method which have body).

 Conditions to use abstract:

1. We can not use abstract classes to initiate objects
directly .
Shape s=new Shape( );
2. The abstract methods of an abstract class must
be defined in its subclass.
3. We can not declare abstract constructor or
abstract static methods.
EXAMPLE
abstract class A
{
abstract void callme ( );//abstract method(no body)
// concrete method are still allowed in abstract class
void callemeToo( )
{
System . out .println( “this is concrete method”);
}}
class B extends A
{
void callme( )
{ System . out .println(“B’s implementation of call
me”);
}}
EXAMPLE
class AbstractDemo
{
public static void main(String args[])
{
B b1=new B( );
A a1=new A( ); // invalid, because we can not
create object of abstract class.
A a1;
a1=b1;
b1.callme( );
b1.callmeToo( );
System . out .println( “call me “ + a1.callme( ) );
}}
NESTED AND INNER CLASS
 It is possible to define class within another class ,
that is known as nested class.
 Nested class has access to member including private
member of class in which it is nested.but that class
can’t access to member of nested class.
 Two types of nested class,

 static
 Non-static
 Nested class are particularly helpful in handling
events in applets.
class A
Outer class
// can’t access member of or
Enclosing class
B
class B

// access variable ob Inner class

Or
class B Enclosed
class
EXAMPLE
class Outer
{
int out_x =100;
void test ( )
{
Inner inobj =new Inner( );
inobj . display( );
// display( ); gives error
}
class Inner
{
int y = 10;
EXAMPLE
void display( )
{
System . out. println( “display : outer_x=“+
out_x);
}
}
void show( )
{
System . out. println( “y=“+ y); //invalid
}
}
EXAMPLE
class InnerClassDemo
{
public static void main (String args[ ])
{
Outer outobj =new Outer ( );
// Inner inobj =new Inner ( );
outobj . test ( );
outobj . show ( );

//outobj. display ( );
}
}
STATIC NESTED CLASS & NON-
STATIC NESTED CLASS
Static nested class:
 Class has static modifier specified.

 It access member of its enclosing class through an

object.
 It can not refer member of its enclosing class directly.

Non-static nested class:

Most important type of nested class is inner class.
 Inner class is non static nested class.

 It can access all variables and method of its outer

class.
 inner class is fully within the scope of its enclosing
class.
 RECURSION
 Recursion is a function that allows method to call itself.
 When recursive method calls itself new local variables
and parameter are removed from the stack and execution
resumes.
 A recursive call does not make a new copy of method but
arguments are new.
 Advantage: it is used to create simple and clearer
version of several algorithm.
 We must have if statement that returns method without
recursive call.
 If you don’t use if statement for recursive call recursive
method goes in the infinite loop.
EXAMPLE
class Sum
{
int sumn( int i)
{
int n;
if ( i==1)
return 1;
else
n=sumn (i-1)+ i ;
return n;
}
}
EXAMPLE
class RecursionDemo
{
public static void main(String args[])

{
Sum s=new Sum( );
int total=s . sumn( 5) ;
System . out .println( “sum of 1 to 5=” + total);
}
}
RETURNING OBJECTS
 A method can return any type of data including class
type (object ) ,which is created by user.
 In this example, each time incrByTen( ) is invoked ,a
new object is created and a reference to it is returned
to calling routine.
EXAMPLE
class Test
{
int a;
Test ( int i)
{
a=i ;
}
Test incrByTen( )
{
Test temp= new Test (a+10 );
return temp;
}}
EXAMPLE
class Return_obj
{
public static void main (String args[ ] )
{
Test obj1=new Test( 2 );
Test obj2;
obj2=obj1.incrByTen( );
System . out . println( “obj1.a=“ + obj1.a );
System . out . println( “obj2.a=“ + obj2.a );
obj2=obj2.incrByTen ( );
System . out . println( “obj2.a after second increase“ +
obj2.a );
}}
EXAMPLE
Output:

Obj1.a=2
Obj2.a=12
Obj2.a after second increment =22
INTERFACE :MULTIPLE INHERITANCE

Why interface is needed?

 Java does not support multiple inheritance directly.

 Means,Java class cannot have more than super class.

Ex:
class C extends B,A
It is not
{ permitted
in Java.
---------
}
INTERFACE :MULTIPLE INHERITANCE
 But large number of real life applications require
the use of multiple inheritance where we can
inherit methods and properties from several
distinct classes.

 Normally for a method to be called from one class

to another ,both classes need to be present at
compile time , javac checks to ensure that the
method signature are same.

 But when there is hierarchy of class functionality

gets higher and higher complicated . interface are
designed to avoid this problem.
INTERFACE :MULTIPLE INHERITANCE
 Java provides an alternate approach interface to
support the concept of multiple inheritance.

 They are designed to support dynamic method

resolution at time

 Java class can not be a subclass of more than

one super class.

 But it can implement more than one interface , this

enabling us to create classes that build upon other
classes without problems created by multiple
inheritance.
INTERFACE
 Interface is basically a king of class.
 Interface contains methods and variable but it defines
only abstract method and final variable.
 Interface do not specify any code to implement
methods(method does not have body) .
 Variables are constant (value can’t be changed).

 Interface defines :

what a class do , but not how it does it

 It is responsibility of class that implements an
interface ,to define code for implementation of these
methods.
SYNTAX TO DEFINE INTERFACE:

access interface interfaceName

{
variable declaration;
method declaration;
}
 Interface is keyword.

 Access : is access modifier ,it must be either

public or not used any other(friendly).
SYNTAX TO DEFINE INTERFACE:
 Declaration of variable :

static final type variablename = value;

Note:
 All variables are declared as constants.

 It is allowed to declared variable without final

and static ,because all variables in interface are
treated as constants.
SYNTAX TO DEFINE INTERFACE:
 Method declaration in interface:

returntype methodname ( parameter-list );

Note :
 Method declaration will contain only a list of methods
(without body) like abstract methods.
 Code of that method will implements by class
which use that method.
 Method declaration ends with semicolon.

 Methods that implement an interface must be declared

public.
EXAMPLE:
interface Item
{
static final int code = 123; // code is constant .
String name= “Fan”; // name is constant.
void display ( ) ;
}
 If no specifier is used then interface is only available to
other members of package in which it is declared.
 If public access modifier used ,then available to other
package also.
HOW TO EXTEND INTERFACE?
 Interface can be extended ,means it can be sub
inherited from interface.
 New sub interface will inherit all member of super
interface in same manner as class.

interface interface2 extends interface1

{
body of interface2
}
EXAMPLE
interface ItemConstant
{
int code =1001;
String name=“Fan”;
}
interface Item1 extends ItemConstant
{
void display( );
}
interface Item extends ItemConstant , Item1
{ -----------
-----------}
HOW TO EXTEND INTERFACE
 While extending interfaces, sub interface can’t define
methods declared in super interface ( because it’s not
class).
 When two or more interfaces are extended by one
interface , they are separated by comma.
 Interface can only extends interface but can not
extend classes.
 If a class that implements an interface does not
implement all methods of interface ,then class
becomes an abstract class , can’t be instantiated.
Note:
 extends : class to class
 extends : interface to interface
 implements : class to interface
HOW TO IMPLEMENT AN INTERFACE IN
CLASS?
 Interface are act as super class whose properties are
inherited by classes.
 Syntax:

class classname implements InterfaceName

{
body of class name
} or
class classname extends SuperClass implements
interface1,interface2….
{
body of classname
}
 VARIOUS FORMS OF INTERFACE
A
interface A implementation
implementation

class B B C

extension class C implements A

class B implements A
class C
(b)
class C extends B implements A
(a)
 interface
A B
extension

interface C
implements class A D interface
class D extension extension

class B E interface
implementation
extension

class C
EXAMPLE
interface Area //interface defined
{
final static float PI=3.14F;
float compute(float x, float y);
}
// interface implemented
class Rectangle implements Area
{
public float compute ( float x , float y)
{
return (x * y);
}}
EXAMPLE
class InterfaceTest
{
public static void main(String args[ ])
{
// class object
Rectangle rect = new Rectangle ( );
// interface object
Area a ;
a = rect ;
System.out.println ( “Area of rectangle =“ +
a. compute(10,20));
}}
INTRODUCTION TO PACKAGE
 OOP’s main feature is its ability to reuse the code
which is already created.
 If we want to use classes from other programs
without physically copying them into program under
development ,then packages are used.
What is package?
 Packages are grouping of variety of classes and/or
Interfaces together.
 Packages are conceptually similar as “class libraries
“ of other languages.
 Packages act as “containers” for classes.
TYPES OF PACKAGE
 Java packages are classified into two types
1) Java API packages
There are six API available in java which is
System defined Package.
2) user defined packages
In java we can create our on package based on
the requirement of User.
BENEFITS OF USING PACKAGES
 The classes contained in the packages of other
program can be easily reused.
 In packages ,classes can be unique compared with
classes in other packages. means two classes in two
different packages can have the same name.
 Packages provide a way to “hide “ classes thus
preventing other programs or packages from
accessing.
 Package also provide a way of separating designing
from coding. It is possible to change implementation
of any method without affecting the rest of the
design.
JAVA API PACKAGE
JAVA SYSTEM PACKAGES AND THEIR
CLASSES
Package
Description
No name
1 java.lang Language support classes
These are classes that java compiler itself uses
and therefore they are automatically imported
They include classes for primitive types, math
functions ,threads and exceptions.
2 java.util •Language utility classes
It includes Vector ,hash tables, random
numbers.
3 java.io •Input/output support classes
They provide facilities for the input and
output of data
JAVA SYSTEM PACKAGES AND THEIR
CLASSES
Package
Description
No name
4 java.net •Network communication supporting
classes
Classes for communicating with local
computers as well as internet servers
5 java.awt Abstract window toolkit
•Set of classes for implementing
graphical user interface.
They include classes for windows ,buttons,
lists, menus and so on..
6 java.
Classes for creating and implementing
applet
applets.
HOW TO USE SYSTEM PACKAGES?
Two approaches are Used.

1) Use fully class name

e.g.: java.awt.Color

Syntax:
import
java.Packagename.classname;
or
import Packagename.*;
NAMING CONVENTION
 Package should begin with lower case letter.
 Every package name must be unique to make best
use of packages. Duplicate name will cause errors
on internet.
 Java suggests to use domain name as prefix to
preferred package name.
 E.g. :

college.student.mypackage
Where
college denotes college name
student denotes student name
CREATING PACKAGE
 To create a package first declare the name of package
using package keyword.
 Syntax: package packagename;

 This must be first statement in source file.

Example:
package firstPackage; //package declaration
public class First Class //class declaration
{
//body of class
}
 Save file as FirstClass.java in directory firstPackage

 .class files must be located in directory firstPackage.

STEPS TO CREATE USER DEFINED
PACKAGE
1) Declare the package at the beginning of file
using
Syntax :package packagename ;
2) Define the class that is to be put in the package
and declare it public.
3) Create a subdirectory under the directory where
the main source file are stored.
4) Store the listing as the classname.java file in
subdirectory created.
5) Compile the file. This creates .class file in
subdirectory.
 PACKAGE
 Java also support concept of package hierarchy .This
allows to group related classes into a package and
then group related packages into a larger package.
e.g. package firstPackage.secondPackage;
Note: store this package in sub directory
firstPackage\ second package.
 A java package can have more than one class
definitions in that case only one class may be
declared as public and that class name with .java
extension is the source file name.
 When a source file with more than one class definition
is compiled .Java creates independent .class files for
those classes.
ACCESSING A PACKAGE
Package statement is used to search a list of packages
for a particular class.
syntax:
import package1 [.package2][.package3].classname;

Package1
(top level) package2
package3
Classname
 Multiple import statements are allowed.
ACCESSING A PACKAGE
 We can also use shortcut approach as follows:
import packagename .* ;
 * indicates that the compiler should search this
entire package hierarchy when it encounters a class
name.
 Drawback of that approach is that it is difficult to
determine from which package a particular member
came.
EXAMPLE
package package1;
public class ClassA
{
public void displayA()
{
System.out.println (“Class A”);
}}
/*source file should be named ClassA.java and stored in
subdirectory package1 and the resultant class
ClassA.class will be stored in same directory. */

e.g. : D:\javapro\package1\ClassA.java
EXAMPLE
import package1.classA;
class Packagetest
{
public static void main(String args[])
{
ClassA objA=new ClassA();
objA . displayA();
}}
In this ClassA imported from package1.
This code should be saved as Packagetest.java and then
compiled.
EXAMPLE

 The source file and compiled file would be saved in

directory of which package1 was a sub directory.
e.g. : D:\javapro\PackageTest.java
 When the Packagetest 1 is run ,java looks for the file
Packagetest1.class and loads it using class loader
.now interpreter knows that it also needs code in the
file ClassA.class and loads it as well.
EXAMPLE
package package2;
public class ClassB
{
protected int m=10;
public void displayB()
{
System.out.println(“class B”);
System.out.println(“m=”+m);
}
}
D:\javapro\package2\ClassB.java
IMPORTING CLASSES FROM OTHER
PACKAGES
import package1.ClassA;
import package2.*;
class Packagetest2
{
public static void main(String args[])
{
ClassA objA=new ClassA();
ClassB objB=new ClassB();
objA.displayA();
objB.displayB();
}}
Path: D:\javapro\Packagetest.java
EXAMPLE:
package pack1; | package pack2;
public class Teacher | public class Courses
{……………} | {……………}
public class Student | public class Student
{……………} | {……………}
import pack1.*;
import pack2.*;
pack1.Student student1; // OK
pack2.Student student2; // OK
Teachers teachers; // No problem
Courses course1; // No problem
SUB CLASSING AN IMPORTED CLASS:
import package2.classB;
class ClassC extends ClassB
{
int n=20;
void displayC()
{
System.out.println(“Class c”);
System.out.println(“m=“+m);
System.out.println(“n=“+n);
}
}
SUB CLASSING AN IMPORTED CLASS:

class PackageTest3
{
public static void main(String args[])
{
ClassC objc =new ClassC();
objc. displayB ();
objc. displayC ();
}
}
 ACCESS PROTECTION
Access
Modifier Friendly Private
public protected Private
Access (default) protected
Location
Same class yes Yes yes Yes Yes
Subclass in
same package yes Yes Yes yes No
Other classes
in same Yes yes Yes No No
package
Subclass in
Yes Yes No Yes
Yes No
other packages
Non-subclasses
in other Yes No No No No
package
ADDING A CLASS TO A PACKAGE
1.Define the class and make it public
2.Place the package statement ------ package p1;
3.Store this file as B.java file under the directory
p1;
4.Compile B.java file. This will create B.class file
and place it in the directory p1.

Java source file can have only one class

declared as public .This is because of the
restriction that the file name of file should be same
as name of public class with .java extension.
CREATE A PACKAGE WITH MULTIPLE
PUBLIC CLASS
1.Declare the name of package
2.Create a subdirectory with this name under the
directory where main source files are stored.
3.Create a class that are to be placed in package in
separate source file and declare the package
statement:
package packagename;
at the top each source file
4.Switch to the sub directory created earlier and compile
each source file .when completed ,the package would
contain .class files of all the source files.
HIDING CLASSES
 When we want to import a package using
import packagename.*;
then all public classes are imported.
 If we want to hide classes from accessing from outside
of the package ,then such classes should be declared
“not public”.
e.g. : package p1;
public class X
{ //body of class }
class Y { //body of class }
import p1.*;
X objx; // ok ,class X is available here
Y objy; // Not Ok,class y is not availablee here
 CLASS PATH
 The compiler and the interpreter searches for the classes
in the current directory and the directory ,which consists
JDK class files.
 All JDK class files and the current directory are
automatically set in your class path.
 But when we want save our class file any other directory
in place of JDK ‘s bin folder, then we have to set
classpath to run that class file.
 A classpath is a list of directories ,which compiler and
interpreter use to search for the respective class file.
CLASS PATH
We can set path as following:
1.javac –d classpath filename
2.set path=“c:\program files\java\jdk1.2\bin”;
3.Globally path set:
follow steps given below:
CLASS PATH
My computer’s properties

Advanced tab

Environment variable

take new variable

set name =path

value=“c:\program files\java\jdk1.2\bin