Core Java Soft

JAVA OOPS
Contents:
S.No Topic Page

Method Overloading 1
Static Keyword 2
Constructors 5
Inheritance 7
Method Overriding 12
Polymorphism 13
FinalKeyword 14
Abstract Classes 17
Packages 19
Practice Material on Interfaces 20
Interfaces 21
Arrays 25
Strings 31
Programs on StringBuffer 35
Exception Handling 37
Inner Classes 46
Multithreading 49
0
Java OOPS
Method Overloading
If you define two methods with the same method name (signature) in a C- language file, it is a
compilation error. That is the following two methods lead to a compilation error in C.
1st Method: void display() {
// code
}
2nd Method: void display(int x) {
//code
}
Observe that, both the above methods have the same method name but differs only in parameters
(the first method does not contain any parameters and the second one contains one parameters). The
same above methods, if written in a OOPs language like C++ or Java, it is not a compilation error.
What is Method Overloading?

Reusing the same method name, with different arguments and with the same or different return type
is called Method Overloading. When overload methods are called, compiler differentiates the
methods depending on their number, type and sequence of parameters. Return type will not be
considered in differentiating the methods by the compiler.
1st Method: void display () {

//code
}
2nd Method: int display () {
//code
}
Even though the return types are different in the above two methods, it is a compilation error.
Where method Overloading is useful?

The OOPs concept, method overloading avoids the usage of several method names that perform
closely related jobs (functionality). That is to say method overloading eliminates the need for entirely
different methods that do essentially the same thing. Overloading also makes it possible for methods
to behave differently based on the arguments they receive.
What is Method Signature?

Method signature includes method name, number of arguments and type of arguments but does not
include written type. That is methods with a different type of return value and having the same name
will be considered as the same method by the compiler and if exists in the same class, it is an error.
IN THIS PROGRAM: Practicing Overloaded Methods using Math.sqrt class

File Name: OverloadDemo.java
Public class OverloadDemo {
Public void area(int x) { //first method

System.out.println(“The area of the circle is “+Math.Pl *x*x);
}
public void area(String figure,int x) { //2nd method
1
if(figure.equals(“circle”))
System.out.println(The area of the is”+Math.Pl*x*x);
else if(figure.equals(“square”))
System.out.println(“The area of the circle is”+x*x);
Else
System.out.println(“Please pass either circle or square only as argument”);
}
public int area(int l,int b) { //3rd method
return l*b;
}
public float area(int a,int b,int c) { //4th method
double s=(a+b+c) / 2;
return(float)(s*Math.sqrt((s-a)*(s-b)*(s-c));
}
public double area(int a,int b,double c) {
double s=(a+b+c) / 2;
return s*Math.sqrt((s-a)*(s-b)*(s-c));
}
public static void main(String args[]) {
OverloadDemo od=new OveloadDemo();
Od.area(5); //invokes 1st method
Od.area(“circle”,7) //invokes 2nd method
Od.area(“squre”,4); //invokes 2nd method
Od.area(“triangle”,10); //invokes 2nd method
System.out.println(“The area of the rectangle is”+od.area(20,10));//3rd method
System.out.println(“The area of the triangle is”+Math.cell(od.area(3,4,5)));//4th
System.out.println(“The area of the triangle is”+Math.round(od.area(3,4,5,6,7)));//5th
}
}
Output:
The area of the circle is 78.53981633974483
The area of the circle is 153.9380400258995
The area of the circle is 16
Please pass either circle or square only as argument
The area of the rectangle is 200
The area of the triangle is 16.0
The area of the triangle is 14
In the above program area () method is overloaded. Math is a class defined in the in the package
java.lang which is imported by default by the JVM (Java Virtual Machine). Math Class includes many
static methods like round (), floor () etc., Student is advised to refer to Java documentation for more
methods and for in depth knowledge of Math class.
Static Keyword
Static keyword functions differently with keywords, methods and classes. We will explore each one by
one.
Using Static Keyword with Variables:

With instance variable, each new instance (object) of the class gets a new copy of the instance
variables. Even though the instance variable is one, each instance enjoys its own copy of the variable
and variable one instance cannot change the variable of the other reason being they occupy different
memory locations. This is made clear to you in my class Employee program where emp1.basic and
emp2.basic are different identities occupying different memory locations and emp1.basic can never
2
access emp2.basic and one cannot corrupt the other even the instance variable basic is one and
same between emp1 and emp2 objects.
There may be a situation where one instance variable may be shared by all instances of the class.
That is every instance of the class must refer (share) to the same instance variable and changing the
value of that variable changes it for all instance of the class. You define these variables as static.
Static variable occupy only one memory location irrespective of the numbers of instances calling
the variable.
IN THIS PROGRAM: Using static keyword with an instance vairiable.

File Name: StaticDemo.java
Public class StaticDemo {
Int x=10;
Static int y=20;
Public static void main(String args[]) {

//System.out.println(“Value of x is”+x);this is an error as instance variable can‟t be called directly
System.out.println(“Value of y is”+y); //can be called directly s it is static
StaticDemo sd=new StaticDemo();
System.out.println(“\nCalling with an instance:”);
System.out.println(“Value of x is ”+sd.x);
System.out.println(“Value of x is”+sd.y);
System.out.println(“\nThree ways of Calling a static variable:”);

System.out.println(“Directly calling:”+y);
System.out.println(“\nCalling with an instance:”+sd.y);
System.out.println(“\nCalling with class name:”+StaticDemo.y);
}
}
Output:
Value of y is 20
Calling with an instance:
Value of y is 10
Value of y is 20
Three ways of Calling a static variable
Directly calling:20
Calling with an instance:20
Calling with class name:20
IN THIS PROGRAM: Another example using static keyword with variable

File Name: StaticDemo1.java
Public class StaticDemo1 {
Static int x=10;

System.out.println(“Value of x is”+x); //prints 10
StaticDemo1 sd1=new StaticDemo1();

System.out.println(sd1.x); //prints 10
X=20;
3
System.out.println(x); //prints 20
Sd2.x=30;
}
}
In the above program, the change in the value of the static variable x, affects the entire program. A
static variable can be re-assigned without the help of an instance also.
Using static keyword with Methods:

Generally, a method in a class should be called with an object (instance) only, like
emp1.computeAndDisplay() in my earlier Employee program. If the keyword static is used within a
method signature, the method can be called without the need of an instance.
IN THIS PROGRAM: using static with method.

File Name: StaticMethod.java
Public class StaticMethod {

Public void display() {
System.out.println(“From display”);
}
public static void show() {
System.out.println(“From show”);
}
//display(); //error,should be called with an instance only as as it is not static
show(); //no error,can be called directly as it static(1st way of calling)
StaticMethod sm=new StaticMethod();

Sm.display(); //no error
Sm.show(); //static method can be called with instance also(2nd way of calling)
StaticMethod.show(); //can be called with classname also(3rd way calling)
//observe how many ways a static method can be called----it is 3 ways
}
}
output:
From show
From display
From show
From show
Can a local variable be static?
No, a local variable can never be static and if so, it is a compilation error. A static variable is also
called a class variable as whole class can access the same variable. Always static implies to whole
class. If local variable is static, the meaning and purpose of static is lost.
Points to remember about static variables:
1. They have the same value for all objects of the class.
2. They are in a common memory location which all objects of that class can refer to.
3. They can be accessed without objects.
4. They can not be made persistent.
4
Points to remember about static Methods:
1. Static methods can be accessed without objects.

2. Static methods can use only static variables.
3. Static methods can be called from static methods only.
Constructors
What is a Constructor?
A constructor looks like a method and is called implicitly by an object when it is created (by new
keyword). Unlike methods, a constructor cannot be called directly. Instead, java calls constructors
automatically. Constructors should be declared before any methods in a class.
Java does three things when new is used to create an instance of a class:
 Allocates memory for the object
 Initializes that object‟s instance variables, either to initial values or to a default (0 for
numbers, Null for objects, False for Booleans, or „\0‟ for characters).
 Calls the constructor method of the class, which might be one of several methods.
Constructors look a lot like regular method with two basic differences:
 Constructor always have the same name as that of class
 Constructor doesn‟t have a return type (even void).
NOTE: Constructors are not methods. Nor are they members.
Overloading the Constructors:
IN THIS PROGRAM: To overload a Constructor.

FILE NAME : Rectangle.java
Public class Rectangle {

Public Rectangle() { //1st constructor
System.out.println(“From Default constructor”);
}
public Rectangle(int x) { //2nd constructor
System.out.println(“Area with one parameter:”+x*x);
}
public Rectangle(double x) { //3rd constructor
System.out.println(“Area with one parameter:”+x*x);
}
public Rectangle(int x,int y) { //4th constructor
System.out.println(“Area with two parameters:”+x*y);
}
public Rectangle(int x,double y) { //5th constructor
}
public Rectangle(double x,int y) { //6th constructor
}
public static void main(String argd[]) {
System.out.println(“Overloading the constructors……\n”);
5
Rectangle rect1=new Rectangle(); //1st constructor is called
Rectangle rect2=new Rectangle(5); //2nd constructor is called
Rectangle rect3=new Rectangle(4.5); //3rd constructor is called
Rectangle rect4=new Rectangle(4,5); //4th constructor is called
th
Rectangle rect5=new Rectangle(4,5.5); //5 constructor is called
Rectangle rect6=new Rectangle(5.5,4); //6th constructor is called
System.out.println(“Overloading the constructor is over”);

}
}
Output:
Overloading the constructors……
From the default constructor

Area with one parameters :25
Area with one parameters :20.25
Area with two parameters :20
Area with two parameters :22.0
Area with two parameters :22.0
Overloading the constructor is over
Default Constructor:
Constructor without arguments (or no-arguments) is called default constructor. If a default
constructor is not provided by the programmer, automatically one will be created by the JVM and
supplied.
For example, in your earlier program Employee.java you have created an object emp1 as follows:
Employee emp1 = New employee ();
Where you have not provided a constructor like Public employee(). In spite of it, your program
worked nice as one is created by the system and implicitly included your program.
To call one Constructor from another Constructor in the same class:

As stated earlier, constructors cannot be called just like methods. Instead constructors are called
automatically when objects (instances) are created. I can say the same in a different fashion: The
birth place of object is a constructor. Java provides a special syntax for calling a constructor from
another. Use this (arg1, arg2, arg3) in a any constructor and that particular constructor will be
called which matches the parameters of this ().
this () must be first statement in a constructor
public class Cloth {
public Cloth () { //1st constructor

System.out.println(“from default constructor”);
}
public Cloth(String name) { //2nd constructor
this (); //this calls1st constructor
System.out.println(“Hello Mr.” + name+”, do you want Cloth?”);
}
public Cloth (int meters) { //3rd constructor
this (“Bhaskar”); //this calls 2nd constructor
System.out.println(“Do you want”+Meters+”Meters Cloth?”);
}
6
public static void main(String args []) {
Cloth cloth1=new Cloth();
Cloth cloth2=new Cloth(“Jack”);
Cloth cloth3=new Cloth(5);
}
}
Output:
From default constructor
Hello Mr. Ramakanth, do you want cloth?
Hello Mr. Bhaskar, do you want cloth?
Do you want 5 meters cloth?
Inheritance
Inheritance is one of the most crucial steps in object – oriented programming, and it has a direct effect
on how you design and write your own java classes.
What is Inheritance?
Inheritance is a mechanism that enables one class to inherit all of the behavior (methods) and
attributes (instance variables) of another class. A class that inherits from another class is a Subclass
and the class that gives the inheritance is called Superclass.
A class can have only superclass (as multiple inheritance is not supported by java), but each
class can have an unlimited number of subclasses. Subclasses inherit all the attributes and behavior
of the superclasses.
What are the advantages of Inheritance?
With inheritance code duplication is avoided by reusing the code(attributes and methods) of one class
in another class. You can derive new classes from already existing classes.
IN THIS PROGRAM: using superclass method in a subclass.

File Name: Rectangle1.java
Class Quadrilateral {
Public void area(int a,int b) {
System.out.println(“Area is”+l*b+”sq.mts.”);
}
}
public class Rectangle1 extends Quadrilateral {
Quadrilateral q1=new Quadrilateral();
Q1.area(5,4);
Rectangle rect1=new Rectangle1();

Rect1.area(3,5);
}
}
Output:
Area is is 20 sq.mts.
Area is 15 sq.mts.
In the above example, the method area () belongs to the class Quadrilateral (called super class)
and this method is used by the class Rectangle(called subclass) as if it is its. The code (here it is
7
method) of one class is used in another class. That is wherever we want area (),we can utilize the
method. This phenomenon is called inheritance and inheritance is the best example for code
reusability at its maximum.
The above source code consists of two classes---one with main() and the other without main().The
class with main should be declared public(if not provided, by default it is assumed) and the file name
must the class name with main() method.
IN THIS PROGRAM: using method and instance variables of a super class in a subclasses.
File Name: MathsBook.java
class Book {
Int qty;
Double price;
Public void amount(int qty,double price) {
this.qty=qty;
this.price=price;
System.out.println(“The bill amount is Rs.”+qty*price);
}
}
class EnglishBook extends Book {
}
class TeluguBook extends Book {
}
public class MathsBook extends Book {
Book b=new Book();
b.amount(5,250.75);
EnglishBook eb=new EnglishBook();

eb.amount(4,150);
TeluguBook tb=new TeluguBook();
tb.amount(10,50.50);
MathsBook mb=new MathsBook();

mb.amount(15,75.25);
}
}
Output:
The bill amount is Rs.1253.75
In the above program, super class Book includes two instance variables qty and price and one
method amount 0 which are used freely by its subclasses EnglishBook,TeluguBook etc.
Behavior of Constructors in Inheritance:
When a default constructor of a subclass is executed, the default constructor of the subclass will call
the default constructor of superclass. After getting executed the superclass constructor only, the
subclass constructor is executed.
IN THIS PROGRAM: Demo on subclass constructor calling superclass constructor.
8
File Name: ConstructorDemo.java
class A {
public A() {
System.out.println(“From A constructor”);
}}
class B extends A {
public B() {
System.out.println(“From B constructor”);
}}
class C extends B{
publc C() {
System.out.println(“From C constructor”);
}}
class ConstructorDemo {
System.out.println(“Instance of class A is created:”);

Aa=newA();
System.out.println(“\nInstance of class B is created:”);

Bb=new B();
System.out.println(“\nInstance of class C is created:”);

Cc=new C();
}
}
Output:
Instance of class A is created
From A constructor
Instance of class B is created

From A constructor
From B constructor
Instance of class C is created

From A constructor
From B constructor
From C constructor
Using super keyword in Inheritance:
1. super with Instance variables:
Super is a Java keyword used to refer the instance variables (non-static) of the parent class
that are hidden by the current class.
IN THIS PROGRAM: using super keyword.

File Name: Son.java
class Father {
9
int age = 60;
public void display_age() {
System.out.println(“Son‟s age;” + age);
}
}
public class Son extends Father {
int age = 25;
public void show_age() {
System.out.println(“Son‟s age;”+age);
System.out.println(“Using super: Son‟s age:” +super.age);
}
public static void main(Sting args[]) {
Father f= new Father();
Son s = new Son();
f.display_age();
s.show_age();
}
}
Output:
Father‟s age: 60
Son‟s age: 25
Using super: Son‟s age: 60
In the above program, both superclass and subclass have the same instance variable age. The
instance variable age of subclass hides the instance variable age of superclass. When a superclass
variable is hidden, it can be called from the subclass by using super keyword.
2. Super with Methods:
When the same method signature exists in both the superclass and subclass, the superclass
method is hidden by the subclass method. That is an object of subclass can not access the
superclass method. In this situation of data hiding, super keyword can be used to access the
superclass method.
IN THIS PROGRAM: Using super keywords with methods.

File Name: Grape.java
Class Cherry {
Public void color() {
System.out.println(“The color of Cherry is red”);
}
}
public class Grape extends Cherry {
public void color() {
System.out.println(“The color of Grape is Green”);
Super.color();
}
public static void main(Strings args[]) {
Cherry cherry = new Cherry();
Grape grape = new Grape();
System.out,println(“Calling Cherry‟s color method:”);

Cherry.color();
System.out.println(“\nCalling Grape‟s color method:”);
10
Grape.color():
}
}
Output:
Calling Cherry‟s color method:
The color of Cherry is Red
Calling Grape‟s color method:

The color of Grape is green
The color of Cherry is red
Using super() in Inheritance:

Super() is used to call a superclass constructor from a subclass constructor. Super() must be the
first statement, if used, in a subclass constructor. If not, it is a compilation error.
IN THIS PROGRAM: Using super () to access superclass constructor.

File Name:Officer.java
Class Worker {
int basic, da, hra ;
public Worker(int a, int b) {
basic = a ; da = b ;
System.out.println(“Worker‟s basic + da is Rs.” + (basic + da));
}
public Worker(int a, int b, int c) {
basic = a; da=b; hra = c;
System.out.println(“Worker‟s basic + da + hra is Rs.” +(basic+da+hra));
}
}
public class Officer extends worker {
public Officer(int p, int q) {
super(p,q);
System.out.println(“Officer‟s basic+da is Rs.”+(basic+da));
}
public Officer(int p,int q,int r) {
super(p,q,r);
System.out.println(“Officer‟s basic+da+hra is Rs.”+(basic+da+hra));
}
public static void main(Sting args[]) {
System.out.println(“Worker constructors in action”);
Worker w1=new Worker(3000 , 1500);
Worker w2= new Worker(4000 , 1800, 500);
System.out.println(“\nOfficer constructors in action:”);

Officer o1=new Officer(10000 , 5000);
Officer o2=new Officer(15000 , 6000 , 2000);
}
}
Output:
Worker constructors in action:
Workers basic + da is Rs.4500
Worker‟s basic + da + hra is Rs. 6300
Officers constructors in action

Worker‟s basic+da is Rs.15000
11
Officer.s basic+da is Rs.15000
Worker‟s basic+da+hra is Rs.23000
Officer‟s basic+da+hra is Rs.23000
Method Overriding
Method overriding involves inheritance. Method overriding occurs when a class declares a method
that has the same type of signature as a method declared by one of its superclasses. Method
overriding is a very important capability because it forms the basis for run-time polymorphism. The
new method hides the method of the super class.
A super class reference variable can be used to refer to a subclass object. The actual version
of an overridden method that is executed is determined at run-time, not at a compile time.
Note: The dynamic method dispatch resolves calls to overridden methods at run-time. In the following
program hello () method is used for overriding. The method is overridden in both the subclasses.
IN THIS PROGRAM: Using method overriding.

File Name: MethodOverridding.java
class A {
void hello() {
System.out.println(“Hello from A”);
}
}
class B extends A {
void Hello() {
System.out.println(“Hello from B”);
}
}
class C extends B {
void Hello() {
System.out.println(“Hello from C”);
}
}
public class Method Overridding1 {
C c = new C(); //A c = new C();
c hello();
}
}
Output:
Hello from C
A c = new C(); In this statement c is an object reference variable of type A, but assigned with an
object of C. The statement can be also written as A c; c = new C(); or new C() hello();
A subclass object can be assigned to a superclass reference variable.
Abstract methods cannot be private but can be protected. While overriding a protected abstract
method, the overridden method can not be more restrictive (in access).
12
Always a member of a class (variable and method) can be inherited. Constructor is not member
and can not be inherited (but can be accessed). Also Constructors cannot be native, abstract,
final, synchronized or static.
Polimorphism Or Dynamic (Late) Binding

Polymorphism is an OOPS concept and means that different objects respond distinctively to the same
message. In Dynamic Binding, the interpreter resides which method is linked to the same object
reference variable at run-time.
IN THIS PROGRAM: Illustrating Polymorphism

File Name : PolymorphismDemo.java
class DesignRules
public void design() {
System.out.println(“Call me by name, I give you different designs at different places”);
}}
class House extence DesignRules {
System.out.println(“The House should consist of a kitchen and Bedroom”);
}}
class Factory extence DesignRules {
System.out.println(“The Factory should provide a fire alarm, siren and canteen”);
}}
class FunctionHall extence DesignRules() {
public void design(){
System.out.println(“The functionhall shoul include kitchen, Dining hall, Weddinghall”);
}}
public class PolymorphicDemo{
public static void main (String args[]) {
DesignRules dr ; //dr is a reference variable
House house = new House ();
Factory factory = new Factory();
Functionhall fn = new Functionhall();
dr = House; dr.design();
dr = Factory; dr.design();
dr = fn; dr.design();
System.out.println(“Iam from main, designs are over sir”);

}}
Output:
The House should consist of a kitchen and Bedroom
The Factory should provide a fire alarm, siren and canteen
The functionhall shoul include kitchen, Dining hall, Weddinghall
Iam from main, designs are over sir
The Same output can be obtained by making class DesignRules as abstract and making its method
abstract.
In Inheritance, only one class should be public that contains the main method. Other should
not be public and doing so is a compilation error.
Final Keyword
13
final keyword behaves differently with variables, methods and classes. We will see each.
final with variables:
final variables cannot be reassigned.final variables are like constant variables(const int x=20) of C-
language.
IN THIS PROGRAM: using final keyword with variables.

File Name: FinalVariableDemo.java
Public class FinalVariableDemo {

int x=10;
final int y=20;
System.out.println(“Values before changing”);

System.out.println(x); //prints 10
System.out.println(y); //print 20
x=100;
//y=200 //compilation error.can‟t assign a value to a final variable
System.out.println(x);
}
}
final with methods:
final keyword is invoked with methods and classes in inheritance. Final methods declared in a
superclass can not be overridden in a subclass. A class declared as final can not be subclassed.
This will be clear with the following two programs.
IN THIS PROGRAM: final keyword with methods.

File Name: FinalMethodDemo.java
Class FinalMethod {
Public void display() {
System.out.println(“From display of super class”);
}
public final void show() {
System.out.println(“From show of super class”);
}
}
public class FinalMethodDemo extends FinalMethod {
public void display() {
System.out.println(“From display of subclass”);
}
/* public void show() { //error as final methods can not be subclassed
System.out.println(“From show of subclass”);
}
*/
FinalMethodDemo fmd=new FinalMethodDemo();
Fmd.display();
Fmd.show();
14
}
}
Output:
From display of subclass
From show of subclass
final with class
final class FinalClass {

}
public class FinalClassDemo extends FinalClass {
}
The program does not compile and complains:can‟t subclass final classes.
Can an instance variable be final?
Yes,an instance can be final.But no instance of the class can change the value.Following is the proof.
Public class FinalClassDemo {

Final int x=10; //final instance variable
FinalClassDemo fmd=new FinalClassDemo();
System.out.println(“fmd.x);
//fmd.x=100;//can‟t assign a value to a final variable
System.out.println(fmd.x);
}
}
Study of Access Modifers:

Class Modifiers:
There are three possible modifiers that may precede the class keyword
Keyword Meaning
Abstract cannot be instantiated

Final cannot be extended
Public can be accessed by any other class.If this
keyword is missing,the access to the class
is
limited to the current package,known as
default package.
Variable Modifiers:
There are seven possible modifiers that precede the declarations of a variable.
Keyword Meaning
final is a constant
private can be accessed by the code within the
same class
protected can be accessed by the code in a
subclass or the same
public can be access by any class package
static is not an instance variable(called as class
variable)
15
Method Modifers:
There are eighth possible modifiers that may precede the declaration of a variable.
Keyword Meaning
final cannot be overridden

abstract cannot be implemented in the same class
native The method is implemented in the machine code
used by the host CPU, not using byte codes
private can be invoked by the code within the same class
protected can be invoked by the code of a sub class in the
same package or any other package
public can be invoked by any class
static Cannot be accessed without an object (called as
class method)
synchronized Acquired to lock when it begins execution
By default any variable is non-final, non-transient and non-volatile.
The following example is an example demonstrating accessibilities of different methods

and variables.
class A {
Private int a=10; //this cannot be accessed from a subclass
int b=20; //default access specifier
protected int c=30;
public int d=40;
private void display() { //this cannot be accessed from a subclass
System.out.println(“From display”);
}
void show() {
System.out.println(“From show”);
}
protected void illustrate() {
System.out.println(“From illustrate”);
}
public void expose() {
System.out.println(“From expose”);
}
}
public class B extends A
B b1=new B()
//System.out.println(b1.a); //this is compilation error
System.out.println(b1.b);
System.out.println(b1.c);
System.out.println(b1.d);
//b1.display(); //this is compilation error

b1.show();
b1.illistrate();
b1.expose();
}
16
}
Access Specifiers at a Glance:
Private Default Protected Public

Same Class Yes Yes Yes Yes
Same package subclass No Yes Yes Yes
Same package non subclass No Yes No Yes
Different package subclass No No Yes Yes
Different package non subclass No No No Yes
Access Specifiers between super class and subclass:
When methods are overridden,the access specifier of the subclass overridden method cannot
be more restrictive than super class method.But it can be wider.
class A {
public void expose() {
System.out.println(“From super expose”);
}
}
public class B extends A {
protected void expose() { //this will not compile as public is restricted to protected
System.out.print(“From sub expose”);
}
B b=b=new B();
b.expose();
}
}
Abstract Classes
Abstract class specifies what functionality is to be provided and not how to provide. That is
subclasses may use deferent implementation to achieve the same objective. Abstract classes cannot
be final. That is to say abstract and final are mutually exclusive.
IN THIS PROGRAM: Using abstract keyword.

File Name:AbstractClassDemo.java
abstract class Shape { //observe the syntax of an abstract class
public abstract void display(); //observe the syntax of abstract method

}
class Circle extends Shape {
public void display() { //display method is overridden,if not compilation error
System.out.pritnln(“The circle have rounded corners”);
}
}
class Rectangle extends Shape {
System.out.println(“The rectangle have right-angled corners”);
//display() method is implemented with code
17
}
}
class Triangle extends Shape {
System.out.println(“The triangle do not hane two right-angled corners”);
}
}
class AbstractClassDemo {
public static void main(String args[]) { //public is assumed
Circle cir=new Circle();

Rectangle rect=new Rectangle();
Triangle tri=new Triangle();
Cir.display();
rect.display();
tri.display();
/*The same output can be obtained through plymorphism also

Shape sha; //creating a super class reference variable,here super class is an
abstract class
sha=cir; sha.display();
sha=rect; sha.display();
sha=tri; sha.display();
*/ }
}
Output:
The circle have rounded corners
The rectangle have right-angled corners
The triangle do not have two right-angled corners
The following is the best example to illustrate practically the purpose an

abstract class and run-time polymorphism.
IN THIS PROGRAM: Using abstract class and polymorphism.

File Name: AbstractJetPlane.java
abstract class JetPane { //abstract class

abstract int numengines(); //abstract method
}
class DC10 extends JetPlane {
int numEngines() {
return 3;
}
}
class DC10 extends JetPlane {
int numEngines() {
return 4;
}
}
class AbstractJetPlane {
public void amin(String args[]) {
System.out.println(“No. of engines DC8 contains”+new DC8().numEngines());
18
System.out.println(“No. of engines DC10 contains”+new DC10().numEngines());
}
}
Output:
No. of engines DC8 contains 3
No. of engines DC10 contains 4
PACKAGES
A package is a group of classes and interfaces. You can assign the classes and interfaces in a source
file to a particular package by using a package statement. The package statement must appear as
the first statement in the source file. It is possible to organize package in a hierarchical manner.
Java class libraries are organized into packages. Some of these are listed below:
Package Description
Java.applet allows you to build applets

Java.awt provides an Abstract Window Toolkit (AWT)
with which user can construct Graphical User Interfaces.
Java.awt.event handles events from AWT components

Java.io supports input and output
Java.lang provides core java junctionality
Java.net enables networking
Java.util offers utility functionality ( like time, date, data structures etc)
To create user defined packages
Let C:\WINDOWS\RK>be your current directory.

Now open an editor to your source file with the following command.
C:\WINDOWS\RK>notepad Dog.java
Write your source file as follows:
package animal;
public class Dog {
int wt = 10:
public void nature( ) { System.out.println( “Dog the most faithful servant” ) ; }
public void weight( ) { System.out.println( “My pet weighs “ + wt +” kgs ”); }
Now compile the above source code as folloes:
C:WINDOWS\RK> javac –d.Dog.java
-d = Keeps the compiled java file(i.e Dog.class) in the package animal.

. = stands for current directory.
Now if you open RK directory,you can find animal directory and you cannot find Dog.class file.That is
above command created a directory by name animal in the current directory RK.If you open the
animal directory you can the see the Dog.class file.
19
Next my aim is to import this package animal in some other directory and call the Dog.class file.
For example ,I go to my parent direrectory(windows) and from there I call.That is my current prompt is
C:WINDOWS>
It is necessary to set the classpath as follows:
C:\WINDOWS>set classpath=C:\WINDOWS\RK;.; %CLASSPATH%;
%CLASSPATH% = appends the earlier classpath

. = Includes current directory
At the prompt C:\WINDOWS opens a new source file as follows:
C:\WINDOWS>notepad PackageDemo.java and write the code as follows:
Import animal; //or import animal.Dog;

Public class PackageDemo {

Dog dog=new Dog();
Dog.nature(); dog.weighs();
}
}
Output:
Dog the most faiyhful servant
My pet dog weighs 10 kgs
Practice Material on Interfaces

Before going into the discussion of interfaces, it is better to review once, the concepts of
method overloading and overriding just you learnt in the previous class.
Summary of Method Overloading:
 The identity of a method is determined by the combination of its fully qualified class name and
also the type, order and count of arguments in the arguments list.
 Two are more methods in the same class (including perhaps the methods inherited from a
superclass) with the same name but different argument lists are called overloaded.
 Methods with overloaded names are effectively independent methods. Using the same name
is really just a convenience to the programmer. Return type, access specifies and exception
list may vary freely.
 Overloaded methods may call one another simply by providing a normal method call with an
appropriately formed argument list.
Summary of Method Overriding:
 An overriding method (largely) replaces the method it overrides. (Overloaded methods

supplement each other).
 Each method in a parent class can be overridden at most once in any one
subclass.(overloadedmethods can exist in any number, in the same class).
20
 Overriding methods must have arguments lists of identical type and order, otherwise they are
treated simply as overloaded methods. (overloaded methods must have different arguments
lists).
 The return type of a overriding method must be identical to that of the method it over rides.
(the return type of an overladed method may be choosen freely).
Some more rules to be observer in method overriding:
 An overriding method must not be less accessible that the method it overrides. (if the
supercass method is public, the subclass method cannot be protected or private).
 An overriding method must not throw any checked exceptions that are not declared for the
overridden method.
Interfaces
An interface defines a protocol behavior. A class that implements an interface adheres to the protocol
defined by that interface. Interfaces like abstract classes provide templates of behavior that other
classes are expected to implement.
What is an interface?
An interface is java keyword used to generically (in general) define constants and methods wherein
the actual implementation for these methods is done by the subclass implementing the interface.
Interfaces, unlike abstract classes, should contain all methods abstract. Abstract class may contain:
 All abstract methods (like interfaces)

 All non- abstract methods
 A mixture of non – abstract methods.

Can an interface be extended?
Yes, in fact interface expects it from you. An interface can be extended just like any other class but
extends keyword should be replaced with another keyword implements.
Does Java support multiple inheritance?
In multiple inheritances, a subclass can have any number of superclasses. Strictly speaking, Java
does not support multiple inheritance, even though it is basically an OOPs concept. For Example, a
bat inherits the properties of birds (flying) and properties of mammals (giving offspring). In java, we
can‟t write a program where a bat object inherits the properties of both bird object and mammal
object.
Isn‟t it (not supporting multiple inheritance) a negative point to java?
Yes, you are right. Actually, it is a negative point to java. Java designers solved this problem through
interfaces where it is possible to a class to implement more than one interface. That is to say that java
supports multiple inheritance through interfaces.
Creating and implementing interfaces:
IN THIS PROGRAM: creating and using an interface.
interface Bird { //writing interface class bird is wrong

public abstract void wings(); //interface method contains nobody
21
public abstract void flying(); //interface method ends with semicolon
}
public class Bat implements Bird { //observe implements instead of extends]
public void wings() { //providing implementation for first interface

method
System.out.println(“Bat has two wings”);
}
public void flying() { //providing implementation for second interface method
System.out.println(“Bat flies at super speeds”);
}
Bat bat = new Bat();
bat.wings();
bat.flying();
//we can also assign a subclass (Bat) object to a superclass interface (Bird) reference variable.
System.out.println(“\nUsing interface reference variable:”);
Bird bird; //creating interface reference variable
bird = bat; //assigning subclass object to interface reference variable
bird.wings(); //calling subclass methods with reference variable
bird.flying(); //we can‟t create objects of an interface like an abstract
class
}
}
Output:
Bat has two wings
Bat files at super speeds
Using interface reference variable:

Bat has two wings
Bat flies at super speeds
If the interface contains more than one method, the subclass which implement the interface must
override all the abstract methods of the interface else it is a compilation error.
Implementing Multiple Interfaces:
The following example shows the multiple inheritance of java regarding interfaces.The above program
is modified a little and shown.
IN THIS PROGRAM: Creating two interfaces and implementing in a sub class.
interface Bird { //1st interface

public abstract void wings();
public abstract void flying();
}
interface Mammal { //2nd interface
public abstract void offspring();
}
public class Bat implements Bird,Mammal { //implementing both interfaces
public void wings() { //implementing the method of 1st interface

System.out.println(“Bat have two wings”);
}
22
public void flying() { //implementing the method of 1st interface
System.out.println(“Bat flies at super speed”);
}
public void offspring() { //implementing the method of 2nd interface
System.out.println(“Bat gives offspring and does not lay eggs”);
}
public static vpid main(String args[]) {
Bat bat=new Bat();

bat.wings();
bat.flying();
bat.offspring();
}
}
Output:
Bat have two wings
Bat flies super speed
Bat gives offspring and does not lay eggs
The sub class must be implement all the methods of all the interface it implementa.
Extending Interfaces:
One interface can extend another interface,but can‟t implement.The above example is slightly
changed and presebted below.
IN THIS PROGRAM: extending one interface to other.

Interface Bird { //first interface
public static final int wings = 2 //instance variable in interface
public abstract void wings();
public abstract void flying();
}
interface Mammal extends Bird { //second interface extending first
public abstract void offspring();
}
public class Bat implements Mammal { //implementing the second
interface
public void wings() {

System.out.println(“Bat has”+wings+”wings”);
}
public void flying() {
System.out.println(“Bat flies at super speeds”);
}
public void offspring() {
System.out.println(“Bat gives offspring and does not lay eggs”);
}
Bat bat = new Bat();
bat.wings();
bat.flying();
bat.offspring();
}
23
}
Output:
Bat has 2 wings
Bat flies at super speeds
Bat gives offspring and does not lay eggs
Some important points to remember about interfaces:
 All methods in an interface must be declare public and abstract and even if omitted, the
methods are public and abstract by default. Generally, programmers omit these access
modifiers as a matter of style.
 All variables in an interface are by default static and final.
 All methods in an interface must be abstract.
 A class can implement any number of interfaces with implements clause.
 When an interface method is implemented, it must be declared as public in the subclass (the
reason: in interface all methods are public by default and in implementation methods cannot
be declared more restrictive in a subclass).
 Interface reference variables can be assigned with objects of a subclasses, just like abstract
classes.
Multiple Inheritance in Interfaces:
One interface can extend any number of interfaces which is not possible in concrete classes.
IN TNIS PROGRAM: extending two interfaces to an interface
interface interface1 {
public abstract void display();
}
interface interface2 {
public abstract void show();
}
interface interface3 extends interface1, interface2 {
public abstract void illustrate();
}
public class MultiinterfaceDemo implements interface3 {
public void display() { System.out.println(“From Display”);}
public void show() { System.out.println(“From show”); }
public void illustrate() { System.out.println(“From illustrate”); }
public void main (String args[]) {
MultiinterfaceDemo mid = new MultiinterfaceDemo();
mid.display(); mid.show(); mid.illustrate();
}
}
Output:
From Display
From show
]From illusrate
Q.No.1
public class Numbers {
public void sum(double x. double y) {
System.out.println(x+””+y);
}
24
Numbers num = new Numbers();
Num.sum(4, 5);
}} the output of the above program is
a) 4 5 b) 4.0 5.0 c) does nt compile as matching method sum with int arguments is not found
d) none Ans: b
Explanation: When a matching method which can tally with the arguments is not found, compiler tries
to implicitly promote the data types ( here, int is promoted to double). 4 and 5 are promoted to 4.0 and
5.0 and printed.
Arrays
Arrays are data structures that can store large amount of data of the same type grouped together and
known by a common name. Each member is called an element of the array. Arrays are capable of
strong primitive data types as well as objects. Like in C / C++, elements are stored in contiguous
memory locations and indexed starting from 0. The elements of the array can be accessed by its
index values. Once array is declared, its size cannot be altered dynamically.
IN THIS PROGRAM: creating and displaying the elements.
Public class ArrayDemo {
int subject[] = new int[5]; //creating an array of type int of 5 elements

System.out.println(“Default value of subject[2];”+subject[2]); //default 0
Subject[0] = 10; subject[1]=20; //start assigning the values toelements
Subject[2] = 30; Subject[3] = 40;
Subject[4] = 50;
System.out.println(“After assigning the value of subject[2]:”+subject[2]); //prints 30
int x=subject.length; //length gives the size of the array
System.out.println(“Size of the subject array is:”+x); //prints 5
System.out.println(“\n Displaying the elements of subject array”);

For(int I=0;I<subject.length;I++)
System.out.println(“subject[“+i+”]=”+subject[I]);
Int rates[]={100,200,300,400,500};
System.out.println(“\n Displaying the elements of rates array”);
For(int i=o;i<rated.length;i++)
System.out.println(“rwtes[“+I+”]=”+rates[i]);
String names[]={“Sumanth”,”Bhaskar”,”Harish”};
System.out.println(“\n Displaying the elements of names array:”);
For(int i=0;i<names.length;i++)
System.out.println(“names[“+i+”=”+names[i]);
}
}
int subjects[]=new int[5] can be split into two statements:
int subjects[];
subjects=new int[5]; The sqare brackets[] can be also placed as:
int[]subjects=new int[5];
25
In the above example subject array is created first and the elements are assigned later.rates array
and names array are initialized.When an array is initialized ,arrey size should not be give in the array
statement.That is int rates[5]={100,200,300,400,500”;is wrong and leads to compilation error even
though the size of the array,5 is correct.
IN THIS PROGRAM: to pass command line arguments.
public class CmmandLine1 {

For(int i=0;i<args.length;i++)
System.out.println(“args[i]);
}
}
Compile the program as usual.While running give the command lile this:
C:\Windows>java CommandLine1 sure rama kanth java lecturer
The output will be sure,rama,kanth and lecturer in separate lines.
IN THIS PROGRAM: to pass command line arguments and parsing to int values.
Irrespective of whether you pass int or double or strings as command-line arguments, every thing will
be converted into strings and passed into the program. If those values are to be used as to the values
are to be converted to int from string form.
public class ArrayPassingDemo {

public static void main(String xyz[]) {
for(int i=0;i<xyz.length;i++)
System.out.println(“xyz[1]);
int x=Integer.parseInt(xyz[1]);
Int y=Integer.parseInt(xyz[2]);
System.out.println(“The product is:”+x*y);
}
}
In the previous programs, args is nothing but an identifier of a string array and it can be any valid
identifier like xyz in the above program. Pass command-line arguments as: java ArrayParsingDemo
10 20 30 40 50.These integer values 10, 20 etc. are passed as strings and we cannot do any
arithmetic operations on these values. A string value can be converted to an int type using parsing
operation as in the above program.
Array elements are passed by pass-by=value and arrays (because arrays are objects) are passes by
pass –by-reference. The following to examples illustrates.
IN THIS PROGRAM: to show array elements are passed by value.

public class PassByValue {
void calculate(int x) {
x = 20;
System.out.println(“From calculate method:”+x); //prints 20
}
PassByValue pbr = new PassByValue();
Int y[] = {10};
System.out.println(“Before passing the value:”+y[0]); //prints 10
26
Pbr.calculate(y[0]);
System.out.println(“After passing the value:”+y[0]); //prints 10
}
}
IN THIS PROGRAM: to show arrays (not array elements) are passesd by reference
public class PassByReference {
void calculate(int x[]) {
x[0] = 20;
System.out.println(“From calculate method:”+x[0]); //prints 20
}
public static void maijn(String args[]) {
PassByReference pbr = new PassByReference();
Int y[] = {10};
System.out.println(“Before passing the value:”+y[0]); //prints 10
Pbr.calculate(y); //array itself is passed
System.out.println(“After passing the value:”+y[0]); //prints 20
} }
The change of value of an array element in the calculate method alters the value of the
element in the main method. Objects are passed by reference in Java.
We can create an array of objects also as in the following examples.
IN THIS PROGRAM: creating an object array
public class CreatingObjectArray {

int x = 10, y = 27:
CreatingObjectArray[] obarray = new CreatingObjectArray[3];
obarray[0] = new CreatingObjectArray();

System.out.println(obarray[1]);
System.out.println(obarray[1].x+obarray[1].y);
Obarray[1].x = 100;
System.out.println(obarray[1].x+obarray[1].y);
}
}
Output:
CreatingObjectArray @bf28676f
37
127
IN THIS PROGRAM: creating a two dimensional array.
public class TwoDimensionalArray {
int que[] [] = { {10,20,30,40}, {100,200,300,400}, {1000,2000,3000,4000} };

System.out.println(que[1] [2]);
27
}
} The output is 300
The above program can be coded also as:
public class ArrayDemo {

int a1[] = {10,20,30,40};

int a2[] = {100,200,300,400};
int a3[] = {1000,2000,3000,4000};
int que[] [] = (a1, a2, a3};
System.out.println(que[1][2]);
}
}
The output is 300.
The following is the matrix from (3 rows x 4 columns) of the above example.
COLOMNS---------
0 1 2 3
10 20 30 40
0
R
O
W 1 100 200 300 400
S
2 1000 2000 3000 4000
Matrix form of a two – dimensional array
So far you have seen the similarities between the arrays of java and C/C++. Now we will
explore the differences.
How the java array differs from that of C or C++?
As far as single dimensional array is concerned, there is no difference at all. In a two

dimensional array, the size of the second of dimension can be varied for every row depending on the
necessary. The needs can be as follows:
Suppose, in the above example rows(first-dimension) represents students and the

columns(second-dimension) represents subjects. Suppose, the second student do not appear for 2nd
subject and third do not appear for 2nd and 3rd subjects the memory allocated to them is waste. In
C/C++, there is no way not to allocate. But in java it is possible not to allocate as the following
example explains:
IN THIS PROGRAM: to have a varied second dimension in a two-dimensional array.
28
Public class ArrayDemo {
int student[] [] = new int[3] []; //2nd dimension size is not mentioned
student[0]=new int[4];
//start assigning element to yhe 2nd dimension
student[0][0]=45; student[0][1]=55; //1st appeared all 4 subjects
student[0][0]=65; student[0][3]=75;
student[1][0]=46; student[1][1]=56;
student[1][2]=66; //2nd students appears 3 subjects only
student[2][0]=88; //3rd students appears only one subject
System.out.println(“student[1][2]); //output 66
}
}
IN THIS PROGRAM:another example on a two dimensional array.
class JavaTwoDimensionalArray {
int numarray[][]={{1,2},{10,20,30},{100,200.300,400}};
//to find the length of each row(1st
dimension)
System.out.println(“The length is the numarray is”+numarray.length);
System.out.println(“The length is the numarray[0] is”+numarray[0].length);
System.out.println(“The length is the numarray [1]is”+numarray[1].length);
System.out.println(“The length is the numarray [2]is”+numarray[2].length);
//TO PRINT THE ELEMENTS OF EACH ROW
for(int i=0;i<numarray.length;i++) { //numarray.length gives no.of rows

for(int i=0;j<numarray[i].length;j++) //gives no.of elements in each column
System.out.println(“numarray[i][j]);
System.out.println();
}
}
}
Output:
The length of the numarray is 3
The length of the numarray[0] is 2
The length of the numarray[1] is 3
The length of the numarray [3]is 4
12
10 20 30
100 200 300 400
To copy one array into another:
29
Syntax: System.out.println(sourceArray,source position,destinationArray,destination
position,no.of elements to be copied);
(method arraycopy is defined in System class of java.lang.package)
IN THIS PROGRAM: copying an array into another array either completely or part.
public class CopyingArray {

//copying whole array:array1 into array2
int[] array1={1,2,3,4,5};
int[] array2=new int[5];
System.arraycopy(array1,0,array2,0,array1.length);
//here,0s represents he starting position of the element in each array and

array1.length
//indicates complete array is to be copied
for(int i=0;i<array2.length;i++) //display the elements of array2

System.out.println(array2[I]+” “);
//to copy part of an array2
System.out.println(); //to give an empty space
int[] numarray1={10,20,30,40,50};
int[] numarray2={100,200,300,400,500,600,700};
System.out.println(numarray1,1,numarray2,2,3);
For(int i=0;I<numarray2.length;i++)
System.out.println(“numarray2[i]+” “);
}
}
Output:
10 20 30 40 50
100 200 300 400 500 600 700
While creating array2,in the above example ,care must be should be taken to make he size of the
array2 to be sufficient to accommodate all the elements of array1.
Assignment sum to students
Create a two-dimensional array of varying 2nd dimension representing rows as subjects and
columns as marks.Print the marks of 2nd student and the marks of 2nd column.Also print the
whole array in a matrix form?
The following is the solution:
In the following example each student subject-wise marks(row) and each subject
Marks of whole class or all students(column) are obtained.
class PlayingWithArrays {
int grades[][]={{1,2},{10,20,30},{100,200,300,400}};
//to obtain the marks of 2nd student(i.e 2nd row)
System.out.print(“Marks of 2nd student:”);
30
for(int i=0;i<grades[1].length;i++) //2nd student array index is 1
System.out.print(grades[1][i]+” “);
//to obtain the marks of subject 2(i.e 2nd column)
System.out.print(“\n Marks of 2nd subject”);
for(int i=0;i<grades.length;i++)
System.out.print(grades[i][1]+” “);
//to obtain the marks in matrix form
System.out.println(“\n Marks in matrix form:”);
for(int i=0;i<grades.length;i++) {
for(int j;j<grades[i].length;j++) {
System.out.print(grades[I][j]+””);
}
System.out.println();
}
}
}
Output:
Marks of 2nd student:10 20 30
Marks of 2nd subject:2 20 200
Marks in matrix form:
12
10 20 30
100 200 300 400
Strings
PROGRAMS ON STRINGS
In C/C++, string is an array of characters and in java string is an object (derived from string class) that
can be assigned with a group of characters enclosed in double quotes. String class cannot be
subclassed as it is declared final in the java.lang package.
The class header of string class is
public final class String extends Object implements java.lang.serializable
Unlike in C/C++, string manipulations are very easy in java. We will study some important methods of
String class.
IN THIS PROGRAM: comparing strings with equals and ==
Public class StringCompare { //equals() is Object class and is inherited by String

Public void main(String args[]) {
String s1=new String(“hello”);
String s2=new String(“good bye”);
String s3=new String(“Happy Birthday”);
String s4=new String(“happy birthday”);
System.out.println(“s1 =”+s1);
if(s1 equals(“hello”)) //test for equality with equals

System.out.println(“s1 equals \”hello\””);
else
System.out.println(“s1 does not equal\”hello\”);
31
if(s1==”hello”) //test for equality with ==
System.out.println(“s1 equals \”hello\””);
else
System.out.println(“s1 does not equal \”hello\””);
if(s3.equalsIgnoreCase(s4)) //test for equality-ignore case

System.out.println(“s3 equals s4”);
else
System.out.println(“s3 does not equal s4”);
//test for equality with compareTo

System.out.println(“s1.compareTo(s2) is”+s1.compareTo(s2));
}
}
Output:
s1=hello
s1 equals “hello”
s1 does not equal “hello”
s3 equals s4
s1.compareTo(s2) is 1
s2.compareTo(s1) is –1
s1.compareTo(s1) is 0
compareTo() compares two strings lexographically (character by character).If both the strings are
same it returns 0 else it returns an integer which is the difference of ASCII code of the two dissimilar
characters.
IN THIS PROGRAM: checking a string with startsWith and endsWith
Public class StringStartEnd {

Public static void main(String args[]( {
String s1=”started”);
String s2=”starting”;
System.out.println(“s1 starts with \”st\” “+s1.startsWith(“st”);

System.out.println(“s1 starts with \”r\” from index 3”+s1.startsWith(“r”,3));
System.out.println(“s1 ends with \”ed\” “+s1.endsWith(“ed”);
}
}
Output:
S1 starts with”st”true
S1 starts with \”r\” from index 3 true
S1 ends with ed”
In startsWith() search begins from start of the string and in endsWith() the search begins from ending
of the string.In the statement s1.startWith(“r”,3),the search for r begins from the character at index 3 in
the string.
IN THIS PROGRAM: locating Characters and Sunstrings with indexOf and lastIndexOf.
32
Public class StringIndexMethods {
String letters=”abcdefghijklmabcdefghijklm”;
System.out.println(“TEST indexOf TO LOCATE A CHARACTER IN A STRING”);

System.out.println(“c is located at index:”+letters.indexOf(„c‟));
System.out.println(“a is located at index:”+letters.indexOf(„a‟));
System.out.println(“$ is located at index:”+letters.indexOf(„s‟)+”\n”);
System.out.println(“TEST lastIndexOf TO FIND AS CHARACTER IN ASTRING”);

System.out.println(“Last c is located at index :”+letters.lastIndexOf(„c‟));
System.out.println(“Last a is located at index:”+letters.lastIndexOf(„a‟));
System.out.println(“Last $ is located at index:”+letters.lastIndexOf(„$‟)+”\n”);
System.out.println(“Test indexOf TO LOCATE A SUBSTRING IN A STRING”);

System.out.println(“\”def\” is located at index:”+letters.indexOf(“def”));
System.out.println(“\hello\” is located at index:”+letteres.indexOf(hello”+”|n”)):
System.out.println(“Test indexOf TO LOCATE A SUBSTRING IN A STRING”);

System.out.println(“last \”def\” is located at index:”+letters.lastIndexOf(“def”));
System.out.println(“Last \”hello\” is located at index:”+letters.lastIndexOf(“hello”));
}
}
Output:
TEST indexOf TO LOCATE A CHARACTER IN A STRING
c is located at index: 2
$ is located at index:-1
TEST lastIndexOf TO FIND AS CHARACTER IN A STRING

Last c is located at index: 15
Last a is located at index: 15
Last $ located at index: -1
Test indexOf TO LOCATE A SUBSTRING IN A STRING

“def” is located at index: 3
“hello” is located at index: -1
Test lastIndexOf TO LOCATE A SUBSTRING IN A STRING

Last “def” is located at index: 16
Last “hello” is located at index: -1
IN THIS PROGRAM: extracting substrings from a string with substring.

public class SubString {
String letters=”abcdefghijklmabcdefghijklm”;
System.out.println(“Substring from index 20 to end is:”+letters.substring(20));

System.out.println(“Substring from index 0 upto 6 is:”+letters.substring(0,6));
System.out.println(“Substring of(1,6):”+letters.substring(1,6));
}
}
Output:
Substring from index 20 to end is:hijklm
Substring from index 0 to 6 is: abcdef //always substring reads 1 past,so make
Substring of(1,6): bcdef //less 1 in the second integer parameter
33
IN THIS PROGRAM: concatenating strings using concat
public class StringConcat {

String s1=new String (“Happy”);
String s2=new String(“Birth Day”);
System.out.println(“s1=”+s1);
System.out.println(“s2=”+s2);
System.out.println(“Result of s1.concat(s2) is :”+s1.concat(s2));
System.out.println(“s1 after concatenation is:”+s1); //s1 is not changed
System.out.println(“s1+s2 is:”+s1+s2); //after concat
}
}
Output:
s=Happy
s2=Birth Day
Result of s1.concat(s2) is : Happy Birth Day
s1 after concatenation is: Happy
s1+s2 is: HappyBirth Day
IN THIS PROGRAM: using the methods replace,toUpperCase,toLowerCase.
Public class String {

String s1=new String(“hello”);
String s2=new String(“GOOD BYE”);
String s3=new String(“ spaces “);
System.out.println(“Replace „l‟ with „L‟ in s1=”+s1.replace(„l‟,‟L‟));

System.out.println(“s1 after toUpperCase=”+s1.toUpperCase());
System.out.println(“s2 after toLowerCase=”+s2.toLowerCase());
System.out.println(“s3 after trim=”+s3.trim());
}
}
Output:
Replace „l‟ „L‟ in s1=hello //replace does not change the original string.SOP(s1) prints hello
S1 after toUpperCase=HELLO
S2 after toLowerCase=good bye
S3 after trim=spaces
IN THIS PROGRAM: USING String.valueOf
IN THIS PROGRAM: stringValueOf() converts to a string form any thing that is passed as parameter.
Public class StringValueOf {

String s1=”Ramakanth”;
String s2=” spaces “;
System.out.println(“Length of s1 is:”+s1.length());
System.out.println(s2.trim());
System.out.println(“4th character in s1 is:”+str.charAt(3));
}
34
}
Output:
Length of s1 is 9
Spaces
4th character in s1 is k
In the above program the number of characters present in the string is found with length()(which is a
method) and is very different from that of length(which is a variable) which is used for find the sixe of
the array.
Programs on StringBuffer
Once if string is assigned a value ,it cannot be changed. It means if a string is reassigned a value, the
original memory location is lost and new memory location is allotted. This phenomenon is called
immutable and is an ovegead to the processor and a negative point for performance. To over come
this lacuna, java designers introduced StringBuffers. StringBuffers are grow able dynamically.
IN THIS PROGRAM: to find the length and capacity of a StringBuffer and using ensureCapasity.
public class StringBuffer {

StringBuffer buf1=new StringBuffer();
StringBuffer buf2=new StringBuffer(10);
StringBuffer buf3=new StringBuffer(“hello”);
System.out.println(“TO CONVERT A StringBuffer TO String”);

System.out.println(“buf3 toString=”+buf3.toString()+”\n”);
System.out.println(“TO FIND THE LENGTH OF A StringBuffer”);

System.out.println(“Length of buf1 is=”+buf1.length());
System.out.println(“TO FIND THE CAPACITY OF A StringBuffer”);

System.out.println(“Capacity of buf1 is=”+buf1.capacity());
Buf1.ensureCapacity(50);
System.out.println(“New Capacity of buf1 is=”+buf1.capacity());
System.out.println(“New length is of buf1 is=”+buf1.length());
}
}
Output:
TO CINVERT A StringBuffer TO String
Buf3 toString=hello //now hello is an String from and not StringBuffer form
TO FIND THE LENGTH OF A StringBuffer

Length of buf1 is=0
Lengrh of buf2 is=0
Length of buf3 is=5
TO FIND THE CAPACITY OF A StringBuffer

Capacity of the buf1 ia=16
35
New capacity of buf1 is 50

New length of buf1 is 50
IN THIS PROGRAM: appending a StringBuffer with append
public class StringBufferappend {

Object o=”hello”; //assign String to Object reference
String s=”good bye”;
boolean b=true;
int i=7;
double d=33.333;
StringBuffer buf=new StringBuffer();
buf.append(o); buf.append(„ „);

buf.append(s); buf.append(„ „);
buf.append(b); buf.append(„ „);
buf.append(l); buf.append(„ „);
buf.append(d);
System.out.println(buf);
}
}
Output:
Hello good bye true 7 33.333
Inserting a String in StringBuffer:
class InsertString {
StringBuffer sb=new StringBuffer(“Rama Kanth”);
System.out.println(sb);
Sb.insert(4,”Bhaskar”); //char also can be inserted in the same way
//for eg. Sb.insert(4,‟A‟);
System.out.println(sb);
}
}
Output:
RamaBhaskar Rao
Revering a StringBuffer:
class Reverse {
StrngBuffer sb=new StringBuffer(“RAMA”);
System.out.println(sb); //prints RAMA
Sb.reverse();
System.out.println(sb); //prints AMAR
}
}
To delete some characters of StringBuffer:
36
public class DeleteChars {
StringBuffer sb1=new StringBuffer(“rama”);
sb1.delete(1,3); //like substring,reads one past,delets am prints ra
System.out.println(sb1);
sb1.append(“Krishna”);
System.out.println(sb1); //prints rakrishna
sb1.delete(0,sb1.length()); //delete complete string
System.out.println(sba); //does not print anything
}
}
One JCP Question: What is the output of the following code?
StringBuffer sb=new StringBuffer(“RAMA”);

sb.setLength(0);
System.out.println(sb);//prints anything,but an empty line of that of println() statement
SetLength() truncates or expanda the previous character string.If
expanding,pads with nulls.
Exception Handling
Practice material on Exception Handling
What is an Exception?
An exception is an abnormal condition that disrupts normal program flow(or execution).

The exception signifies an illegal, invalid or unexpected situations like:
 The file you try to open may not exist.

 The class file you want to load may be missing or in the wrong format.
 The other end of the network connection may be non-existent.
 The network connection may be disrupted due to some mysterious reason.
 An operand is not in the exceed the size of array and a divisor operatrion cannot be zero.
If these abnormal conditions are not prevented or at least handled properly,the program may
be aborted(terminated).
Observe the following program:
public class ExceptionUnhandled {

int a=10;b=0;c;
try {
c=a/b;
}
catch(ArithmaticException e) {
System.out.println(“I caught the exception:”+e);
}
System.out.println(“Okay”);
}
}
37
Output:
I caught the exception:java.lang.ArithmaticException:/ by zero
Okay
Two new statements you can find in the above program. Due to these changes, an exception
message and Okay are printed. The flaws(defects) in the code which can be detected at
compilation-time are called Bugs and that of at run-time(execution-time) are called
exceptions.
In the above programs, the statement c=a/b, raises an exception called Arithmetic Exception
(all exceptions have got names, which we will see later).As exception raised, the 1st program
(class ExceptionUnhandled) displays the exception message and the program terminates
without printing okay. In the second program, the exception is handled by two new keywords
try and catch. As exception is handled, the exception message is displayed and okay is
printed.
The process of dealing exceptions, as in the above second program, is called Exception
Handling.
What is the mechanism of Exception Handling java adopt?
The statements which you think may raise exceptions simply move them to try block. In the
above program, such statement is c=a/b and is moved into a try block. The exception raised in
the try block, should be handled at some point of the program and it is the catch block. The
catch block is capable enough to handle the exception. In the catch block, exception name (in
previous example, it is Arithmetic Exception and it is a class by itself. All exceptions are
defined in java.lang.package) is written followed by some message you would like to point
(apart system‟s)in case of exception occurs. The message is written in a println statement.
Are try and catch methods?
They look like methods but not.In java,you know,a method should have a return type(atleast
void) and access specifier (atleast default).But try and catch do not have any of these. try and
catch are blocks a(and not called methods)-try block and catch block and later you may get
another called finally block.
Suppose in the second program,if b is not equal to zero,will he try-catch blocks raise an error
though exception possibility is not there?
If exception is not raised ,the JVM simply forgets the try-catch blocks and will be treated as a normal
program.That is,the exception handling mechanism(providing try and catch blocks)invoked(implicitly
by JVM)only when exception is raised and if not JVM simply forgets.
Another program which raises an exception.
Public class ExceptionDemo {

int subject[]={35,45,55,65};
try {
System.out.println(subject[5]);
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(“I caught the exception: “+e);
}
38
}
}
Output:
I caught the exception:java.lang.ArithmaticException:/ by zero
Okay
In the above program, the exception is ArrayIndexOutOfBoundsException(in the previous

example it is Arithematic exception) which is raised by the statement Subject [5]. There is no
5th element in the subject array and the element that do not exist is tried to display for some
result. It is an exception in java which is handled by catch block successfully and the program
execution continues and prints Okay. If it is in C/C++, a garbage value is printed. This is an
example, where java is designed robust.
Observe the following by try block code:

try {
System.out.println(“This statement will not print”);
}
Two print statements are present in the above try block. When the first one raises an exception,
control comes into the catch block as expected, but after executing the catch block, control does not
go back into the try block to execute the second println statement. From catch block, the control
proceeds to the next (below the catch block) and prints Okay (not shown in the above fraction of code.
What is finally block?
Suppose in place of second println statement, if an important statement is present which must be
executed, then what about its fate. The second statement may be some times to free the system
resources of files which if not freed, memory leak may occur. Move such of these important
statements into a finally block. Finally block guarantees the execution for its statements whether
exception is raised or not.
The following program displays the semantics of a finally block:
public class FinallyDemo {

int subject[] = {35,45,55,65};
try {
System.out.println(“Not Okay”);
}
catch(ArrayIndexOutBoundsException e) {
System.out.println(“I caughtthe exception:”+e);
}
finally {
}
} }
Output:
55
Not Okay
Okay
In the above program three println statements (two from try block and one from finally) got
executed as exception is not raised as subject [2] is within the array index range. Now change the
39
index to say 5---- an exception is raised. In this situation two print statements (one from catch and
one from finally) are got executed. That is whether exception is raised (second case, subject[5]) or
not (first case, subject[2]), finally is executed.
Move any important statements, whose execution is to be guaranteed, to finally block. Other way to
put it is, the finally block guarantees the execution of code which you place in it.
Can a catch handle more than one exception ?
No, not possible, if you desire to handle more than one exception, write more number of catch blocks
and note that each catch block cannot handle more than one exception. A single try block can have
any number of catch blocks.
IN THIS PROGRAM: to use more than one catch block.
class MultipleCatchDemo {
int a = 10, b = 0, c;
int[]subject = {35,45,55,65};
try {
System.out.println(c = a/b);
}
catch(ArithmeticException e) {
System.out.println(“I caught”+e getMessage());
}
catch(ArrayIndexOutBoundException e) {
e.printStackTrace();
}
} //e.Message() and e.printStackTrace() are another way of getting exception
information.
}
Before going into details still further, we will study about the hierarchy of exception.
Object IOException
Throwable InterruptedException ArithmeticException
Exception ClassNotFoundException
NegetiveArraySizeException
Error RuntimeException
IndexOutOfBoundException
ArrayIndexOutBoundsException
StringIndexOutBoundsException
Hirearchy of Exception
Checked exceptions vs Unchecked exceptions:
40
Checked exceptions are exceptions that are not subclass of Runtime Exception class and must be
checked(handled) by the programmer and if not, the code does not compile.
Unchecked exceptions are the subclass of Runtime Exception which even when not handled by the
program, the program compiles( but execution stops at some point). That is to say, the unchecked
exceptions may be unchecked by the programmer (of course, the danger prevails, if he checks,
program execution proceeds are not).
Using throws keyword:
Some times the author of a method wants to warn others against the possible dangers (or exceptions)
that may occur if they use his method. See how an author( the language designer) wants the possible
exception that may occur when a file is to be opened.
public FileInputStream(String name) throws FileNotFoundException
He wants the possibility of not existing the file which the user want to open. The author warns by
placing the exception in the method(here, constructor) header itself with throws clause. Any one who
wants to use the constructor has to handle the exception(using try – catch) or atleast throw the
exception( we will see how to use throw keyword later).
IN THIS PROGRAM: to use throw keyword.
import java.io
class ThrowsDemo {
public static void display() {
try {
FileInputStream fis = new FileInputStream(“Employee.Java”);
}
catch(FileNotFoundException e) {
System.out.println(“Some problem in file opening”+e.getMessage());
}
System.out.println(“From display method, File successfully opened”);
}
public static void show() throws FileNotFoundException {
FileInputStream fis = new FileInputStream(“ExceptionHandled.java”);
System.out.println(“From show method, File successfully opened”);
}
public static void main(String args[]) throws FileNotFoundException {
display();
show();
}
}
The FileNotFoundException is handled in two ways by the two methods ------ display() and show().
Display() writes try – catch and show() throws the exception. throws helps the show() method only to
get compiled and if actually exception is raised (that is, if the file ExceptionHandled.java is not found)
program execution does not proceed further.
Because show() is called (which throws FileNotFoundException) by the main method, main method
whould also throw the FileNotFoundException. For display() method it is not necessary to throw
because display() handles the exception in try – catch blocks.
41
If FileNotFoundException is not caught by the display() method, the following compiler‟s message is
displayed:
Exception.java.io.FileNotFoundException, must be caught or must be declared in the throws

clause of this method”
A method can throw more than one exception if it wants by separating with commas, See the
following servlet method which throws more than one exception.
Public void services(ServletRequest req, ServletResponse res) throws ServletException,

IOException
User Defined Exceptions:
Sometimes the exceptions defined in java language may not convey understandable meaning to a
common user. For him, you can design an exception and you can explicitly throw it at an appropriate
situation.
IN THIS PROGRAM: creating and throwing an user defined exception.

class NoMoney Exception extends Exception {
NoMoneyException(String message) {
Super(message);
}
}
public class Bank {
public static void main(String args[]) throws NoMoneyException {
int balance = 500.withdraw_amount = 1000;
if(withdraw_amount>balance)
throw new NoMoneyException(“Sorry, not enough balance please”);
}
}
The same exception message can also be used to show the balance to the user. Just replace
the message with(“Sorry, not enough balance please. Your balance is Rs.”+balance);
Exceptions between superclass and subclass (important for JCP exam)
Rule: An overridden subclass method cannot throw more than a superclass method. It can throw the
same or less number of exceptions. The following examples illustrate.
import java.io.*; //this package is to be imported for all I/O operations

class A {
public void display()throw FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream(“a.dat”);
System.out.println(“From super”);
fis close(); //close()method throws IOException
} //FileInputStream(String filename)constructor throws FileNotFoundException
}
public void display() throws FileNotFoundException { //display() is overridden
FilleInputStream fis = new FileInputStream(“a.dat”);
System.out.println(“From sub”);
}
public static void main(String args[]) throws FileNotFoundException {
B b = new B(); b.display();
42
}
}
The above program works nice and gets you output as subclass overridden display() method throws
less number of exceptions than the superclass display() method. In the next example the subclass
method throws more number of exceptions than superclass method and for this reason the program
does not compile.
import java.io.*;
class A {
public void display()throw FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream(“a.dat”);
}
}
public void display() throws FileNotFoundException { //display() is overridden
FilleInputStream fis = new FileInputStream(“a.dat”);
fis close();
}
public static void main(String abc[]) throws FileNotFoundException {
}
}
In the above example, the superclass display() throws only one exception FileNotFoundException.
The subclass overridden display() method throws FileNotFoundException and also IOException. As
subclass method is throwing more exceptions than superclass method, the program never compiles
and throws the error message “Their throws clauses are incompatible”.
Access specifies between superclass and subclass (important for JCP exam):
Rule: An overridden method cannot have more restrictive access specifier than that of superclasss
one.
We know, the order of wider accessibility between access specifier in descending order is: public,
protected, default, private. Observe the following example.
class A {
}
}
protected void display() {
}
}
}
Observe the access specifiers of the overridden display() method. In the superclass it is public
and in subclass it is protected. As the overridden method got a more narrow access specifier than the
superclass, the program does not compile. The compiler complains “The access modifier is made
more restrictive”.
43
A real application of User defined Exceptions:
Suppose a guy goes to Ocean Park to ride a Roller coaster. Riding a Roller Coaster is dangerous for
kids and as well as for aged people as it involves speedy somersaults (tilts). Now we will write a
program ------ when the are is entered by the computer operator, he must get the appropriate
message:
import java.io.*;
class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
public class RollerCoaster {
static int age, lowerAgeLimit = 15, upperAgeLimit = 60;
public static void main(String args[]) throws AgeException {
try {
System.out.print(“Enter Your Age”);
DataInputStream dis = new DataInputStream(System.in);
String str = dis.readline();
age = integer.parseint(str);
}
catch(IOException e) {
}
if(age<15) {
System.out.println(“Please come after”+(lowerAgeLimit)+”years”);
Throw new AgeException(“Sorry, now you are too YOUNG to ride a RollerCoaster
Dear”);
}
else if(age>60) {
System.out.println(“You would have come before”+(age-upperAgeLimit)+”Years”);
Throw new AgeException(“Sorry,now you are too old to ride a RollerCoaster Sir”);
}
else
System.out.println(“Enjoy the ride on a RollerCoaster”);
} }
Just run the above program with different ages as input and enjoy Roller Coaster riding. Do
not bother right now about the Input/Output mechanism in the above program.
IN THIS PROGRAM: to demonstrate a nested exception.

public class NestedTry {
in subject[]={35,45,55,65};
try {
System.out.println(“Not Okay”);
try {
}
catch (ArithmeticException) {
System.out.println(“Frominner try:”+e);
}
44
}
catch(ArrayIndexOutBoundsException e) {
System.out.println(“From outer try:”+e);
}
}
}
Output:
55
Not Okay
From outer try : java.lang.ArrayIndexOutBoundsException:5
The inner try block should have it‟s qwn catch block.In the program ,as inner catch is given to
catch some other exception like arithmetic exception ,the outer catch will catch the exception as inner
failed.
IN THIS PROGRAM: to demonstrate the propagation of exception.
public class ExceptionPropagation {
public static void display() {

try {
show();
}
catch(ArithmaicException e) {
System.out.println(“I caught:”+e);
}
System.out.println(“I am Okay”);
}
public static void show() {
int a=10,b=0,c;
c=a/b;
}
display();
}
}
Output:
I caught:java.lang.ArithmaticException:/ by zero
I am Okay
In the above program,exception is thrown by the one method(show) and caught by another
method(display),because display calls the show method.We can still propagate the exception.Remove
try-catch in display() method for show() and write try-catch in main method for display().Still the
program works.
Inner Classes
Definition: An inner class(nested) is a class that is declared in another class.
Inner classes are introduced in jdk1.1.Fundamentally,an inner class is the same as any other
class,but is declared inside some other class as a member or inside a method. The complexity of
inner classes to scope and access,particularly access to variables in enclosing(outer) class.
public class OuterOne { //outer class (enclosing class)
45
int x=10; //variable belonging to outer class
public class InnerOne { //inner class as a member of outer class
int y=20; //variable belongs to inner class
public void InnerMethod { //a method of inner class
System.out.println(“x from inner method:”+x;
System.out.println(“y from inner method:”+y);
}
}
}
public void outerMethod() { //a method of outer class
System.out.pritln(“x from outer method:”+x);
//the following two statements raises a compilation error due to the scope of y
System.out.println(“y from outer method:”+y”);
System.out.println(“y from outer method:”+io.y”);
}
OuterOne oo=new OuterOne();
OuterOne.InnerOne io=new OuterOne().new InnerOne();
oo.outerMethod();
io.innerMethod();
}
}
Output:
x from outer method: 10
x from inner method: 10
y from inner method : 20
In the above program,the inner class InnerOne is like a member method of class outerOne and can
not act as independent class.The inner class works in the context of outer class.As with member
access and method invocation,it is important that the this reference be valid when you try to use
it.Inside a static method there is no this reference,which you must take special efforts in these
conditions.
An instance of Innerclass can only exist within an instance of Outer class
In the above example,we can not instantiate InnerOne as usual like InnerOne io=new InnerOne() as
inner class do not have existence by itself being a nested class.Now if you refer the directory you will
find two compiled classes:OuterOne.class and InnerOnesOuterOne.class.Observe the sign for the
Inner class.
In the above example,the statement

OuterOne.InnerOne io=new OuterOne().new.InnereOne();
Can be replaced with
OuterOne.InnerOne=oo.new.InnerOne();
The above program is modified further a little:
public class OuterOne {

static OuterOne.InnerOne io; //an instance variable of type OuterOne.InnerOne
int x=10; //and the scope of io is for all the outer class
public class InnerOne {
int y=20;
public void innerMethod () {
System.out.println(“x from inner method:”+x);
System.out.println(“y from inner method:”+y);
46
}
}
public void outerMethod() {
System.out.println(“x from outer method:”+x);
//System.out.println(“y from outer method:”+y);//error undefined variable y
System.out.println(“y from outer method:”+y);
}
OuterOne oo=new OuterOne();
io=oo.new InnerOne();
oo.outerMethod();
io.innerMethod();
}
}
Output:
x from outer method: 10
y from outer method: 20
x from inner method: 10
y from outer method: 20
The modification of the program is due to the following reasons:
1. to access inner class instance variable(y) from the outer method,we used inner class
object(io).io is referenced first in the instance variable position of outer class and made static
as it is accessed(created object) through the static main() class.If io is not referenced like
this,undefined variable io is displayed by the compiler.
2. to call the inner method using outer method instance (oo),the statement should be
oo.io.innerMethod() ass oo can not access the inner class method directly.
Declaring an inner class inside a Method of outer class:
In the previous examples, the inner class InnerOne enjoys the status of a member. Now we will
declare a method in side a method of outer class and see the scope of variable.
public class MOuter {
public void display(int x,final int y) { //non-final variable of outer class
final int b=x-y; //final variable of outer class
class MInner { //an inner class inside the method of outer class
public void show() {
//System.out.println (“x is”+x); //illegal as x is not final
System.out.println(“y is”+y); //legal as y is final
//System.out.println (“a is”+a); //illegal as a is not final
System.out.println(“b is”+b); //legal as b is final
} //closing of show method of inner class
/* Minner mi=new Minner/();mi.show();must be declared after class closing brace and before
method closing brace else displays Invalid method declaration:method name required
*/
} //Minner class closing brace
Minner mi=new Minner();
mi.show();
} //display method of outer class closing brace
Mouter mo=new new Mouter();
47
Mo.display(40,50);
}
}
Output:
Y is 50
B is –10
In the above program, the inner class can access only final variables of the enclosing (outer) class.
That is the reason why x and a are illegal (as they are not final) and y and b are legal (as they are
final).In the directory, you will find two .class files: Mouter.class and Mouter$1$MInner.class.$1$
appears as Minner is a nested inside a method of outer class.
Static Inner classes:

An inner class can be static also as in he following example:
public class First {

static class Display {
public static void print(String s) {
System.out.println(s);
} //print method
} //display class
First.Display.print(“Hello RamaKanth”);
}
}
Output:
Hello RamaKanth
In the above example,both inner class and method of inner class are declared as static.As they are
static only we are able to call First.Display.print(“Hello RamaKanth”) from main() method.
Methods of static inner class can not access instance variables of the enclosing class.This is similar to
the ruled that apply to static methods in ordinary class.
Anonymous Inner Class
An anonymous inner class is an inner class that does not have a name.Because they do not have a
name,they must be instantiated at the same point thet are difined.The best example is the way we use
an adapter class in window closing as coded below:
AddWindowListener(new WindowAdopter()
{
public void windowClosing(WindowEvent e)
{
system.exit(0);
}
}
Some facts about Nested Classes:
1. Like other classes,nested classes can be declared abstract and final.The meaning of
these two modifiers is the same as for ordinary classes.
2. The access modifiers-private,public,protected and package may be used to restrict the
access to nested classes just as they do not to other class members.
3. An inner class can have any accessibility,including private.
48
4. Inner classes,unless static,have access to the variables of the enclosing class
instance.Additionally,inner classes defined in method scope have read access to finsl
variables of the enclosing method.
Multithreading
A thread is a single sequential (separate) flow of control within program. Sometimes, it is called an
execution context or a light weight process. A thread itself is not a program. A thread cannot run
on it‟s own. Rather, it runs within a program. A program can be divided into a each package of code-
Each representing a thread having its own separate flow of control. That is, a thread can‟t exist by
itself. It is a part of a program.
Light weight process: A thread is considered a light weight process because it runs within the
context of a program (within the program)and takes advantage of the resources allocated to that
program.
Heavy weight process: In the heavy weight process, the control changes in between threads
belonging to different processes (i.e. two different programs.).(In light weight process, the control
changes in between threads belonging to same (one) process)
Execution context: A thread will have its own execution stack and program counter. The code
running within the thread works only within that context.
Package Support of Threads:
java.lang.Thread: In the java language, threads are objects that derive from java.lang. Thread class.
We can subclass the Thread class to get the functionality of the thread. Thread is a concrete class.
java.lang.Runnable: Runnable is an interface which provides an abstract method run() for a thread.
java.lang.Object: This is the root class for every class and defines the three methods for use of
threads.The methods are wait(),notify() and notifyAll().
Java language has two keywords related to the threads: volatile and synchronized.Both of these
keywords help ensure the integrity of data that is shared between two concurrently running threads.
run() method: The run() method is available both in Thread class and Runnable interface.We can
subclass a Thread class and override the run() method.We write the specific code,which we would
like to do by the thread,in the run() method is the heart of any Thread.run() method is called
implicitly by the start() method.
In java, we can create threads in two ways.---one by sub classing the Thread class and one by
implementing Runnable interface.
A program by subclassing the Thread class
We can create threads by extending Thread class to our class. In the following program, the class
Using Thread extends the class Thread. By this, every object of class Using Thread becomes
implicitly a thread(i.e. it can utilize all the methods of Thread class).
Example: printing 10 numbers by using a thread. Thread class is extended.

File Name: UsingThread.java
49
public class UsingThread extends Thread //Thread class is extended
{
public void run() //write the code specific to the thread in run() method
{
try
{
for(int I=1;I<11;I++)
{
System.out.println(“Hello”+I);//prints Hellow 10 times
Thread.sleep(1000); //with a gap of 1000 milliseconds
}//which makes a thread to sleep(not functoing)for the specific time
catch(InterruptedException e)
{
}
System.out.println(“Done”); //When run‟s job is over Done is printed
}
{
UsingThread ut=new UsingThread();
Ut.start(); //a thread startd it‟s functoing with start() method only
}
}
The run() method of UsingThread class overrides the empty run() method of Thread class with a for
loop that iterates 10 times.Between each iteration it sleeps for 1 second(1000 milliseconds).After the
loop has finished it prints Done.
About sleep() method
Sleep() is a method of Thread class with the following signature:
Public static void sleep(long milliseconds)throws InterruptedException
Sleep () method is static and throws (claims) a checked exception InterrupedException. That is, when
ever we use, sleep () method, we should take care of InterruptedException by providing try-catch
block.sleep() method makes a running(active) thread not to run(inactive) for the specified milliseconds
of time. When the sleep time expires, the thread becomes automatically active. The active thread
executes the run() method code. When the thread comes out of the run() method, it dies(naturally, the
work assigned to it is over. That is why, we write the code that is to be done by the thread in run ()
method.
UsingThread ut=new UsingThread();

ut.start();
In the above first statement,a thread by name ut is created(ut is actually an object of

UsingThread class,but becomes implicitly a thread as the class has extended Thread
class).The thread ut is in born state and is inactive.The inactive thread cannot call run()
method.The thread in born state occupies the memory resources but cannot take
microprocessor time.
In the second statement,we call the start() method on the thread.start() method
implicitly calls run() method.The thread in run state is active and utilizes microprocessor time.
50
A program by implementing Runnable interface
The above program is rewritten by implementing Runnable interface (instead of extending Thread
class). Everything is same but for the small difference of writing implements instead of extends.
Another difference is that the run() method in Thread class is a concrete method and it is left to the
subclass to override it or not(any how, we will override).The same run() method in Runnable interface
is an abstract method. that is, the subclass that implements the Runnable interface must override the
run() method.
Example: printing 10 numbers by using Runnable interface

File Name: UsingRunnable.java
public class UsingRunnable implements Runnable

{
public void run()
{
try
{
for(int I=1;I<11;I++)
{
System.out.println(“Hello”+I);
Thread.sleep(1000);
}
}
catch(InterruptedException e) { e.printStackTrace(); }
System.out.println(“Done”);
}
UsingRunnable ur=new UsingRunnable();
Thread t=new Thread(ur);//this line is extra than the previous program
t.start();
}
}
We cannot call ur.start () directly and if called raises a compilation error. This is because the object ur
(or the class UsingRunnable( is no way connected to the start() method of Thread class. To overcome
this,java designers provided a way of passing ur as an argument to the Thread constructor.t.start()
implicitly calls the run() method of UsingRunnable class.
Instance of UsingRunnable class is passed as a parameter to the Thread constructor. And instead of
starting the object ur,object of Thread class is started. This is the difference between the above two
programs.
Using Multiple threads
We can execute different threads concurrently (and is the purpose of a multithreaded program).The
source code includes three programs-FirstThread, SecondThread and TwoRuns. FirstThread and
SecondThread classes extend Thread class.The objects of these classes are created and their start()
methods are called from Two runs class.
Example: to execute two run methods and observe with different sleep periods.
File Name: TwoRuns.java
class FirstThread extends Thread

{
51
public void run()
{
for(int i=1;i<5;i++)
{
System.out.println(“First Thread:”+i);
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
}
}
}
}
class SecondThread extends Thread
{
public void run()
{
for(int i=1;i<5;i++)
{
System.out.println(“Second Thread:”+i)
try
{
Thread.sleep(1000);
}
}
}
}
public class TwoRuns
{
FirstThread ft=new FiestThread(); //create the objects of the classes
SecondThread st=new SecondThread(); //each object is a thread implicitly
ft.start(); //start the threads
st.start(); //there is not shortcut to start both the threads at a time
try
{
ft.join();
st.join();
} //join method throws IonterruptedException
}
}
Output:
First Thread 1
Second Thread 1
First Thread 2
Second Thread 2
First Thread 3
Second Thread 3
First Thread 4
52
Second Thread 4
Note:Change the sleep timings of both the run methods,and observe the output‟s
frequency.
After running the above program,keep try-catch of join() methods in comments,and see
the defference in output(order of execution).
Life Cycle of a Thread
Just like applets and servlets, threads too got a life cycle between their birth (thread object creation)
and death (thread object garbage collection).life cycle constitutes different stages a thread can
undergo in its life(it‟s existence). If your class is already extending any class (e.g., Applet or Frame),
the choice left to you is only implementing Runnable interface. Otherwise, you are left with any choice.
At any time, a thread is said to be in one of the several thread states. A thread just created (but not
started), is in born state. The thread remains in this state until the thread‟s start() method is called;
this causes the thread to enter the ready state. A thread in ready state is eligible to utilize
microprocessor time. A thread enter the dead state when it‟s run() method completes or when it‟s
stop method is called. A dead thread cannot enter again the run state as it is garbage collected. When
running thread‟s sleep method is called, that thread enters the sleeping state. A sleeping thread
enters the ready state again when the sleep time expires. A sleeping thread cannot use
microprocessor, even if microprocessor is idle.
When on a running thread, if suspend () method is called, the thread enters suspended state. A
suspended thread becomes ready with resume () method. A suspends thread cannot use processor
time, even if it is available.
When on a running thread, if wait() method is called, the thread enters a waiting state where it will be
waiting in a queue of threads(used in synchronization).The thread comes into ready state when
notify() is issued on the thread by another thread.
A thread enters the dead state when its method completes or stop () method is called. The stop ()
method sends a Thread Death object to the thread. ThreadDeath is a subclass of class Error.
Thread class
The Thread class is included in java.lang package, a package that is implicitly imported into every
program. The super class of Thread is Object class. Thread class plays a vital role in java‟s
multithreading. Just like any other java class, the thread class is rich with its methods having different
functionality. Following is the class signature:
public class Thread extends Object implements Runnable
Constructors Description
public Thread() creates a thread with default name

public Thread(String name) creates a thread with name
public Thread(ThreadGroup group,String name) creates a thread in a thread group with name
Fields When to use
public final static int MIN_PRIORITY=1 to associate a thread with minimum priotity
public final static int NORM_PRIORITY=5 to associate a thread with normal priority
53
public final static int MAX_PRIORITY=10 to associate a thread with maximum
priority
Methods What that give

public static native Thread currentThread() returns the current thread being executed on the
microprocessor
public static native void sleep(long mills) throws keeps thread in blocked state
InterruptedException
public final String getName() returns the name of the thread
public final void setName(String name) sets a name to a thread
public final native Boolean isAlive() returns true if a thread is alive else false if dead
public boolean isInterrupted() returns true if a thread is interrupted
public void run() by default run method is called
public final int getPriority() returns the priority of the thread
public final void setPriority(int priority) sets a priority to a thread
public synchronized native void start() starts a thread
public final void stop() stops a thread and when stopped garbage
collected
public final void suspend() to suspend a thread
public final void resume() to resume a thread which is suspended
Thread Priority
The order of execution of multiple threads ion a single CPU, depends on the scheduling. The java
runtime supports a scheduling algorithm called fixed priority scheduling. The algorithm schedules
the threads based on their priority relative to other Runnable threads. Every java thread has a priority
in the range Thread.MIN_PRIORITY(of constant 1) and Thread.MAX_PRIORITY (of constant 10).By
default, each thread is given a priority of Thread.NORM_PRIORITY (of constant 5).Each new thread
inherits the priority of the thread that creates it.
The job of the thread scheduler is to keep the highest-priority thread running all the time and for the
threads of same priority, time slices are allocated in round-robin fashion.
A thread‟s priority can be adjusted with setPriotity () method. In the following program, different
priorities are set to two different threads and their output is studied. Naturally, the thread with higher
priority will execute first.
Example: to set different priorities to threads.

File Name: PriorityDemo.java
public class PriorityDemo extends thread

{
public void run()
{
for(int i=0;i<5;i++) //currentThread()returns an object of Thread(that is being run on
the microprocessor time)
String str=Thread.currentThread().getName();
System.out.println(str+”:”I);
}
}
public static void main(String args[])
{
PriorityDemo pd1=new PriorityDemo(); //creating thread objects
PriorityDemo pd2=new PriorityDemo();
54
pd1.setName(“First Thread”);//giving names for the threads
pd2.setName(“Second Thread”);
pd1.setPriority(Thread.MIN_PRIORITY);//setting priority to the threads
pd2.setPriority(Thread.MAX_PRIORITY);
pd1.start();//starting the threads
pd2.start();
//to read to the priorities of threads
System.out.println(“Priority of pd1:”+pd1.getPriority());
System.out.println(“Priority of pd2:”+pd2.getPriority());
}
}
Output:
Second Thread:0 //thread of priority 10(MAX_PRIORITY)executes first
Second Thread:1
Second Thread:2
Second Thread:3
Second Thread:4
Priority of pd1:1 //next,thread of priority 5(NORM_PRIORITY),the default of main executes
Priority of pd2:10
First Thread:0 //thread of priority 1(MIN_PRIORITY)executes last
First Thread:1
First Thread:2
First Thread:3
First Thread:4
55

Core Java Soft

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Core Java Soft

Hochgeladen von

Copyright:

Verfügbare Formate

JAVA OOPS

S.No Topic Page

What is Method Overloading?

1st Method: void display () {

Where method Overloading is useful?

What is Method Signature?

IN THIS PROGRAM: Practicing Overloaded Methods using Math.sqrt class

Public void area(int x) { //first method

Using Static Keyword with Variables:

IN THIS PROGRAM: Using static keyword with an instance vairiable.

Public static void main(String args[]) {

System.out.println(“\nThree ways of Calling a static variable:”);

IN THIS PROGRAM: Another example using static keyword with variable

Public class StaticDemo1 {

Static int x=10;

System.out.println(“Value of x is”+x); //prints 10

StaticDemo1 sd1=new StaticDemo1();

Using static keyword with Methods:

IN THIS PROGRAM: using static with method.

Public class StaticMethod {

StaticMethod sm=new StaticMethod();

Can a local variable be static?

Points to remember about static variables:

1. Static methods can be accessed without objects.

NOTE: Constructors are not methods. Nor are they members.

Overloading the Constructors:

IN THIS PROGRAM: To overload a Constructor.

Public class Rectangle {

System.out.println(“Overloading the constructor is over”);

From the default constructor

Employee emp1 = New employee ();

To call one Constructor from another Constructor in the same class:

this () must be first statement in a constructor

public class Cloth {

public Cloth () { //1st constructor

What are the advantages of Inheritance?

IN THIS PROGRAM: using superclass method in a subclass.

Rectangle rect1=new Rectangle1();

EnglishBook eb=new EnglishBook();

MathsBook mb=new MathsBook();

Behavior of Constructors in Inheritance:

IN THIS PROGRAM: Demo on subclass constructor calling superclass constructor.

System.out.println(“Instance of class A is created:”);

System.out.println(“\nInstance of class B is created:”);

System.out.println(“\nInstance of class C is created:”);

Instance of class B is created

Instance of class C is created

Using super keyword in Inheritance:

1. super with Instance variables:

IN THIS PROGRAM: using super keyword.

2. Super with Methods:

IN THIS PROGRAM: Using super keywords with methods.

System.out,println(“Calling Cherry‟s color method:”);

System.out.println(“\nCalling Grape‟s color method:”);

Calling Grape‟s color method:

Using super() in Inheritance:

IN THIS PROGRAM: Using super () to access superclass constructor.

System.out.println(“\nOfficer constructors in action:”);

Officers constructors in action

IN THIS PROGRAM: Using method overriding.

A subclass object can be assigned to a superclass reference variable.

Polimorphism Or Dynamic (Late) Binding