FIVE WEEKS SUMMER TRAINING

REPORT
On
Core and advanced java

Submitted by
Rakesh reddy Donthiredddy
Registration No: 11603855

Programme Name: JDBC

Under the Guidance of

Mr. Kaki kiran Kumar

Name of the Industry Coordinator

Teach Tech Service
School of Computer Science & Engineering
Lovely Professional University, Phagwara

(June-July, 2018)
 DECLARATION

I hereby declare that I have completed my five weeks summer training at Teach Tech Services
from 05-06-2018 to 13-07-2018 under the guidance of I have declare that I have worked with
full dedication during these Five weeks of training and my learning outcomes fulfill the
requirements of training forth award of degree of B.Tech (Computer Science) in Lovely
Professional University, Phagwara.

RakeshReddyDonthiredddy

Registration no: 11603855

Date:
 SUMMER TRAINING CERTIFICATE

ACKNOWLEDGEMENT

At the outset I convey my heartiest regards to, Dr. Reshmi Mittal, Pro-Cancellor, Lovely
Professional University, for her valuable support and help in completing my summer training.

My sincere and grateful thanks toDr.Gaurav, Head of the Department, Department of

Computer Science for his immeasurable support for successful completion of summer
training.

I express my deep sense of gratitude and whole hearted thanks to all my family members,
relatives and friends for their moral support and encouragement.

RakeshReddyDonthiredddy
Reg No: 11603855
 TABLE OF CONTENT

Chapters Page No
1. Introduction 1
2. Technology Learnt 2-11

3. Reason for choosing thistechnology. 12

4. Learning Outcome 13-17

5. Gantt chart (In case of trainingonly) 18

6. Bibliography 19
 1. INTRODUCTION TO JAVA

Java is a programming language created by James Gosling from Sun Microsystems (Sun)
in 1991. The first version of Java (Java 1.0) was released in 1995. Java is the name of the
island in Indonesia, which is famous for tree plantation so java used a tea symbol as a
logo. Sun Microsystems was acquired by the Oracle Corporation in 2010. Over time new
enhanced versions of Java have been released. The current version of Java is Java 1.8
which is also known as Java 8.

The Java runtime allows software developers to write program code in other languages
than the Java programming language which still runs on the Java virtual machine.
The Java platform is usually associated with the Java virtual machine and the Java core
libraries.

BENEFITS OF JAVA LANGUAGE

The major difference being OOPS concept, C++ is an object oriented language whereas C
language is a procedural language. Apart form this there are many other features of C++
which gives this language an upper hand on C language.

Following features of C++ makes it a stronger language than C,

1. There is Stronger Type Checking in C++.

2. All the OOPS features in C++ like Abstraction, Encapsulation, Inheritance etc makes
it more worthy and useful for programmers.
3. C++ supports and allows user defined operators (i.e Operator Overloading) and
function overloading is also supported in it.
4. Exception Handling is there in C++.
5. The Concept of Virtual functions and also Constructors and Destructors for Objects.
6. Inline Functions in C++ instead of Macros in C language. Inline functions make
complete function body act like Macro, safely.
7. Variables can be declared anywhere in the program in C++, but must be declared
before they are used.
 2. TECHNOLOGY LEARNT

The Java language was designed with the following properties:

Platform independent
Object-orientated programming language
Strongly-typed programming language
Interpreted and compiled language
Java is case-sensitive.
Public class Hello World {
Public static void main (String [] args) {
System.out.println ("Hello World") ;}
}
Class

A class is defined by the class keyword and must start with a capital letter. The body of a class
is surrounded by {}.

Class MyClass {

The data associated with a class is stored in variables.

The behavior associated to a class or object is implemented with methods.

A class is contained in a text file with the same name as the class plus the .java extension.

Object: object is an instance of a class. Each object is created based on the class definition.
The class can be seen as the blueprint of an object, i.e., it describes how an object is created.

Inheritance

A class can be derived from another class. The derived class is called subclass and derived
from is the base class using extends keyword.

The class from which the subclass is derived is called a superclass.

Inheritance allows a class to inherit the behavior and data definitions of another class.

Class MyBaseClass {

Public void hello () {

System.out.println ("Hello from MyBaseClass");
 }
}
Class MyExtensionClass extends MyBaseClass {
}
Exception handling in Java

In Java an exception is an event to indicate an error during the runtime of an application. So

this disrupts the usual flow of the application’s instructions.

In general exceptions are thrown up in the call hierarchy until they get catched.

Checked Exceptions:

Checked Exceptions are explicitly thrown by methods, which might cause the exception or re-
thrown by methods in case a thrown Exception is not caught.

So when calling methods, which throw checked Exceptions the Exceptions, have either to be
caught or to be re-thrown.

Public void fileNotFoundExceptionIsCaughtInside () {

Try {
CreateFileReader ();
} catch (FileNotFoundException e) {
Logger. Error (e.getMessage (), e);
}
}

Public void fileNotFoundExceptionIsReThrown () throws FileNotFoundException {

CreateFileReader ();
}

Public void createFileReader () throws FileNotFoundException {

File file = new File ("F:\java");
New FileReader (file);
}

Checked Exceptions are used when an error can be predicted under certain circumstances, e.g.,
a file which cannot be found.

4.8. Runtime Exceptions

Runtime Exceptions are Exceptions, which are not explicitly mentioned in the method
signature and therefore also do not have to be catched explicitly.

The most famous runtime exception is the NullPointerException, which occurs during
runtime, when a method is invoked on an object, which actually is null.

Public void causeANullPointerException () {

String thisStringIsNull = getMessage (false);
thisStringIsNull.toLowerCase ();
}
Public String getMessage (boolean messageIsAvailable) {
if(messageIsAvailable) {
return message;
}

return null;
}

Java interfaces

An interface is a type similar to a class and is defined via the interface keyword. Interfaces are
used to define common behavior of implementing classes. If two classes implement the same
interface, other code which work on the interface level, can use objects of both classes.

interface defines methods. Classes can implement one or several interfaces. A class which
implements an interface must provide an implementation for all abstract methods defined in
the interface.

Abstract, default and static methods in Interfaces

An interface can have abstract methods and default methods. A default method is defined via
the default keyword at the beginning of the method signature. All other methods defined in an
interface are public and abstract.

Interfaces can have constants which are always implicitly public, static and final.

Public interface MyInterface {

String URL = "http://www.google.com";
void test ();
void write (String s);
default String reserveString (String s){
return new StringBuilder(s).reverse().toString();
}
}

Implementing Interfaces

A class can implement an interface. In this case it must provide concrete implementations of
the abstract interface methods. If you implement a method defined by an interface, you can
use @Override annotation. This indicates to the Java compiler that you actually want to
implement a method defined by this interface. This way the compiler can give you an error in
you mis-typed the name of the method or in the number of arguments.

Public class MyClassImpl implements MyInterface {

@Override
Public void test () {
 }
@Override
Public void write (String s) {
}
Public static void main (String [] args) {
MyClassImpl impl = new MyClassImpl ();
}

}
Multiple inheritances of methods

If a class implements two interfaces and if these interfaces provide the same default method,
Java resolves the correct method for the class by the following rules:

Superclass wins always against the super interface - If a class can inherit a method from a
superclass and a super interface; the class inherits the superclass method. This is true for
concrete and abstract superclass methods
In all other cases the class needs to implement the default method
Public interface A {
default void m () {}
}

Public interface B {
default void m () {}}

Public class C implements A, B {

@Override
Public void m () {}
}
Public class C implements A, B {
@Override
Public void m () {A.super.m () ;}
}
Functional interfaces

All interfaces that have only one method are called functional interfaces. Functional interfaces
have the advantage that they can be used together with lambda expressions. The Java compiler
automatically identifies functional interfaces. The only requirement is that they have only one
abstract method. Several default Java interfaces are functional interfaces:

Java also contains the java.util. Function package which contains functional interfaces which
are frequently used.

Variables and methods

Variables allow the Java program to store values during the runtime of the program.

There are two types of variables primitive type and reference type.
A primitive variable contains the value. A reference variable contains a reference to the object.
Hence, if you compare two reference variables, you compare to use the object1.equals
(object2) method call.

Instance variable is associated with an instance of the class (also called object). Access works
over these objects. Instance variables can have any access control and can be
marked final or transient. Instance variables marked as final cannot be changed after a value
has been assigned to them.

Local variable

Local variable declarations cannot have access modifiers. Local variables do not get default
values, so they must be initialized before they can be used.

Final is the only modifier available to local variables. This modifier defines that the variable
cannot be changed after the first assignment.

Methods

A method is a block of code with parameters and a return value. It can be called on the object

Public class MyMethodExample {

Void tester (String s) {
System.out.println ("Hello World");
}
}

Methods can be declared with var-args. In this case the method declares a parameter which
accepts everything from zero to many arguments.

Overwrite of a superclass method: A method must be of the exact same return parameter and
the same arguments. Also the return parameter must be the same.

Overload methods: An overloaded method is a method with the same name, but different
arguments. The return type cannot be used to overload a method.

Main method

A public static method with the following signature can be used to start a Java application.
Such a method is typically called main method. Public static void main (String [] args) {}

Constructor

A class contains constructors that are invoked by the Java runtime to create objects based on
the class definition.

Constructor declarations look like method declarations except that they use the name of the
class and have no return type.

It must be name of a class. We can have several constructors with different parameters.
Public class MyConstructorExample2 {String s;
Public MyConstructorExample2 (String s) {
this.s = s;}
}
Public class MyConstructorExample {
Public MyConstructorExample () {
}
}

Every object is created based on a constructor. This constructor method is the first statement
called before anything else can be done with the object.

Modifiers

There are three access modifiers keywords available in Java: public, protected, private

There are four access levels: public, protected, default and private.

They define how the corresponding element is visible to other components.

Table 1. Access Level

Modifier Class Package Subclass World

public Y Y Y Y

protected Y Y Y N

no modifier Y Y N N

private Y N N N

Class methods and class variables

Class methods and class variables are associated with the class and not an instance of the
class, i.e., objects. To refer to these elements, you can use the class name and a dot (".")
followed by the class method or class variable name.

Class methods and class variables are declared with the static keyword. Class methods are also
called static methods and class variables are also called static variables or static fields.
If you define a static variable, the Java runtime environment associates one class variable for a
class no matter how many instances (objects) exist. The static variable can therefore be seen as
a global variable.

If a variable should be defined as constant, you declare it with the static and the final keyword.

The static method runs without any instance of the class, it cannot directly access non-static
variables or methods.

Abstract class and methods

A class and method can be declared as abstract. An abstract class cannot be directly
instantiated.

If a class has at least one method, which only contains the declaration of the method, but not
the implementation, then this class is abstract and cannot be instantiated.

If a class contains an abstract method, it also needs to get defined with the abstract keyword.

Public abstract class MyAbstractClass {

Abstract double return Double ();
}

Type Conversion

If you use variables of different types Java requires for certain types an explicit conversion.

Conversion to String
// Convert from int to String
String s1 = String.valueOf (10); // "10"
// Convert from double to String
String s2 = String.valueOf (Math.PI); // "3.141592653589793"
// Convert from boolean to String
String s3 = String.valueOf (1 < 2); // "true"
Conversion from String to Number
// Conversion from String to int
Int i = Integer.parseInt (String);
// Conversion from float to int
Float f = Float.parseFloat (String);
// Conversion from double to int
Double d = Double.parseDouble (String).

If-then and if-then-else

The if-then statement is a control flow statement. A block of code is only executed when the
test specified by the if part evaluates to true. The optional else block is executed when the
if part evaluates to false.

Switch

The switch statement can be used to handle several alternatives if they are based on the same
constant value.

Switch (expression) {
Case constant1:
Command;
Break;
Case constant2:
Command;
Break;
...
default:
}
Boolean Operations

Use == to compare two primitives or to see if two references refer to the same object. Use
the equals () method to see if two different objects are equal.

&& and || are both Short Circuit Methods which means that they terminate once the result of
an evaluation is already clear.

Loops in Java
The for loop

A for loop is a repetition control structure that allows you to write a block of code which is
executed a specific number of times. The syntax is the following.

For (initialization; expression; update statement)

{
}
Public class ForTest {

Public static void main (String args []) {

For (int i = 1; i < 10; i = i+1) {

System.out.println ("value of i: " + i);
}
}
}.
The while loop

A while loop is a repetition control structure that allows you to write a block of code which is
executed until a specific condition evaluates to false. The syntax is the following.
While (expression)
{
}

The following shows an example for a while loop.

17.3. The do while loop

The do-while loop is similar to the while loop, with the exception that the condition is checked
after the execution. The syntax is the following.

do
{
} while (expression);
18. Arrays
18.1. Arrays in Java

An array is a collection of homogenous data type. An item in an array is called an element.

Every element can be accessed via an index. The first element in an array is addressed via the
0 index.

18.2. Enhanced for loop for Arrays and Collections

Arrays and collections can be processed with a simpler for loop.

For (declaration: expression)

{
}
Strings
The String class represents character strings. All string literals, for example, "hello", are
implemented as instances of this class. An instance of this class is an object. Strings are
immutable, e.g., an assignment of a new value to a String object creates a new object.

To concatenate Strings use a StringBuilder.

StringBuilder sb =new StringBuilder ("Hello ");

sb.append ("Eclipse");

String s = sb.toString ()

Compare Strings in Java

To compare the String objects s1 and s2 use the s1.equals (s2) method.

A String comparison with == is for object reference to the same value, equals is used to check
the value.

String a = "Hello";
String b = "Hello";
if (a==b) {
}
This comparison would fail.
String a = "Hello";
String b = new String ("Hello"); if (a==b) {} else {}
Lambda expression

The Java programming language supports lambdas as of Java 8.

A lambda expression is a block of code with parameters. Lambdas allow specifying a block of
code which should be executed later.

If a method expects a functional interface as parameter it is possible to pass in the lambda

expression instead. The type of a lambda expression in Java is a functional interface.

FILE I/O
Data is subdivided into two categories:
 Character data
 Binary data
Character data is stored by using Reader/Writer.
Binary data is in form of streams.
A stream is stored by using input & output stream.
There are different kinds of reader and writer classes.
We have:
 File
 File Writer
 FileReader
 Buffered writer
 BufferedReader
 PrintWriter
File: File f=new file (“ABC.txt) -> with this new file we cannot create the ABC file.
We have to use f.create new file ().
We can create directory using f.mkdir ().
File class Constructors: file f=new file (string name) ->name may file name or directory
name.
File f=new file (“subdirectory”, “filename”) ->to represent resources in a directory.
File f=new file (file subdir, string name) ->to represent resources in a directory.
File Methods: fileobject.exists () -> It is used to check the existence of a file, it returns 1.
Boolean fileobject.createnew file () ->If file exist, it returns false.
Boolean fileobject.mkdir () ->if directory exists, then it returns false.
Boolean f.isfile () -> to check whether it is file or not.
Boolean f.isDirectory () ->to check whether it is directory or not.
Long length () -> returns the length of file.
Boolean delete () ->It returns true when the object is deleted.
Limitations: some systems\n will not identify as new line.
FileReader: To read character data from file.
Constructors: File Reader Fr=new file Reader (string name) ->passing the file name as an
argument.
File Reader Fr =new file Reader (file f) ->Passing file Reference.
Methods:
It reads some of the primitive types.
Int read () ->it read one byte, Unicode value of a character.
Int read (char [] ch) ->it read character array.
Void close () -> to close the file.
Limitations: while reading data using FileReader, we can read character by character which
is not convenient to the programmer.
Constructor: File writer fw=new file writer (string name) ->passing file name to the file
writer.
File writer fw=new file writer (file f) ->passing reference of the file, but this constructor
overrides the
Existing data.
Appending to data: file writer fw=new file writer (string fname, Boolean append) ->If
append is true, it writes at the end of file.
File writer fw=new file writer (file f, append).
Methods of File Writer:
Write (int ch)
Write (char [] ch)
Write (String s)
Flush () -> complete written to the file.
Close ()
Limitations: file writer in which \n should add explicitly, which is difficult to the
programmer.
Buffered writer:
Constructors:
Buffered writer BW=new Buffered writer (writer w);
Buffered writer BW=new Buffered writer (new File Writer (“abc.txt”))
Methods:
Newline () ->to insert a line separator.
Limitations:
We cannot write all primitive data using write method.
Still using newline () method is problem.
Buffered Reader: It can read data line by line from the line, which is not possible file
reader.
Constructors:
BufferedReader br=new BufferedReader (Reader r).
Methods:
Int read ()
Int read (char [] ch)
Void close ()
Strings redline () ->It returns null, if there is no line in a file.
Print writer: It is the most enhanced writer to write character data to the file.
The main advantage of printWriter is we can write any type of primitive type data directly to
the file.
Constructors: printWriter pw=new printWriter (string fname);
PrintWriter pw=new printWriter (file f);
PrintWriter pw=new printWriter (writer w);
Methods:
Print (char ch)
Print (int i)
Print (double d)
Print (Boolean b)
Print (String s)
Flush ()
Close ()
Conclusions: Reader is buffered Reader.
Reader & writer are to handle character data.
Streams
Stream is a sequence of data, in java a stream is composed of bytes.
There are three streams in java
Data input stream
Object input stream
File input stream
FileOutputStream:
It is used to write data to file.
Package: Java.io.*
COLLECTION FRAMEWORK
Collection:-Collection is an interface which can be used to represent a group of individual
objects as a Single entity. If we want to represent a group of individual’s objects as a single
entity then we should go for collection..
Functionality of collections:-
Collections are growing able in nature.
Collections can hold both Homogenous and Heterogeneous elements.
Interfaces of collection Framework:-A collection is a utility class present in
java.util.package to define several utility methods (like Searching, Sorting….) for collection
objects.
Collection (I)
List (I)
Set (I)
Queue (I)
Collection: Collection is an interface which can be used to represent a group of individual
objects as a single entity.
Methods used for Implementation:-
 add (object o) -> It is use to add an object.
 add All (Collection C) ->It is used to add set of (or) group of objects from collection
into current collection object.
 remove (object o) ->To remove a specific object.
 Remove all (collection C) ->To remove group of objects.
 Clear () ->to remove all objects.
 retain All (collection c) ->It is to remove group of objects except collection c.
 Is Empty () ->It is used to check collection is empty or not.
 Size () ->It is used to know the size of collections.
 Contains (object o) ->It is used to check the availability of given object c.
 Contains All (Collection c) ->It is used to check the availability of group of objects.
List (I):
List is child interface of collection.
If we want to represent a group of individual objects as a single entity where duplicates are
allowed and insertion order preserved then we should go for list.
We can differentiate duplicate by using index.
Since list is the child of collection, all the methods are applicable for list as well.
Methods used for implementation:-
Add (int index, object o) ->Add object at a specific index.
Add All (int index, Collection c) -> add group of objects from specified index onwards.
Remove (int index) ->Object is removed from a specific index.
l.indexof ("a") ->it returns index of first occurrence.
l.lastindexof ("a") ->it returns the occurrence of object at last index.
get (int index) ->it returns the object at a specified index.
Set (int index, object o) ->it is used to replace the object at specified index and returns old
object.
Implementation of classes:
Array List:-
It is resizable or grow able array.
Duplicates are allowed.
Insertion order is preserved.
Heterogeneous objects are allowed, because in these two objects will be placed in sorting
order.
Null insertion is possible.
Various Constructors in Array List:-
Array list al=new Array list () ->creates an empty Array List It creates an object with initial
capacity 10.when it reaches to maximum of its length new capacity is allocated.
New capacity= (current capacity*3/2) +1.
Array list al=new Array list (int initial capacity) ->If we cannot create Array list with
required capacity.
Array list=new Array list (collection c) -> If we create a Array list from linked list (or) Tree
set...
Specification:-
Every object in the collection implements serializable and clone able Interfaces.
Array list and vector list have the property of random access to an element.
Random-access (I) present in java.util.package.
It doesn’t contain any methods and It is a marker Interface.
Array list is the best choice, If our frequent operation is retrieval operation.
Array list is the worst choice, if our operation is Insertion (or) deletion in the middle.
Linked List: - Linked list is best used for Insertion and deletion, but is not efficient for
retrieval.
Insertion order is preserved, Duplicates, Null Insertion and heterogeneous objects are
allowed.
We can use Linked list for Implementing stack and queues.
Constructors for Linked list:
Linked list ill=new Linked list () ->Creates an empty Linked list object.
Linked list ill=new linked list (collection c) ->creates an equivalent linked list collection
object.
It is present in java.util.* package.
Vector (): It is a data structure of resizable array or grow able array.
Duplicate objects, Null insertions, heterogeneous objects are allowed.
Insertion order is preserved.
Vector class is serializable; clone able and random-access Interfaces.
Most of the methods present in the vector are synchronized; hence vector object is threading
safe.
Constructors of vector class: - vector v=new vector () -> default size is 10.
Vector v=new vector (int initial capacity);
Vector v=new vector (collection c);
Stack:-It is the child class of vector.
It is specially designed class for LIFO.
Constructors: - stack s=new stack ();
Methods used for implementation: push (object o) ->add element from top.
Pop () -> remove element from top of stack.
Peek () ->return top element of the stack.
Empty () ->It is used to check whether the stack is empty or not.
Search () ->It returns offset (if the object present in stack it return position else It return -1.
SET
It is the child interface of collection.
Duplicates are not allowed and insertion order is not preserved.
Sorted Set:
It is child interface of set.
Duplicates are not allowed, If we want to represent group of objects should be inserted
according to some sorting order.
Default order for numbers -> ascending order.
Default order for strings -> Alphabetical order.
Methods used to implementation:
Object first ()
Object last ()
Sorted headset ()
Sorted tailset ()
Comparator () ->object that describes underlying sorting technique. if we are using default
natural sorting order then we will get null.
Iterator: It is universal cursors, we can perform read and remove operation.
Methods: Public Boolean hasnext ()
Public object next ()
Public void remove ()
Limitations of Iterator:
Only forward direction cursors.
Only read and remove operations.
There is no replace, addition of new objects are not present with iterator.
Listiterator (I):
 It is bidirectional cursor.
Read, remove, replacement, addition of new object.
Public Listiterator List iterator ();
Listiterator lit=l.listIterator ();

Hashset:
It uses Hashtable.
Duplicates are not allowed.
Heterogeneous and nullable are allowed.
Insertion order is not preserved; all objects will be inserted based on hashcode of objects.
Serializable and cloneable but random random-access.
Hash set is best for searching.
Constructors for Hashset:
Hashset h=new Hashset (); -> It has default initial capacity is 16.
Fill ratio is 0.75 It is called Load factor.
Hashset h=new Hashset ( int initial capacity)
Hashset h=new Hashset (int initial capacity, float load capacity)
Hashset h=new Hashset (collection c)
Linked Hashset: It is child class of Hashset.
If we want group of objects, where duplicates are not allowed, but insertion order preserved
then we go for LinkedHashset.
It is used for cache based.
Tree set: The data structure for treeset is balanced tree.
Duplicates, heterogeneous objects are not allowed; we will get runtime exception saying class
cast exception.
Null insertion is allowed, but only once.
Treeset Constructors:
Treeset t= new Treeset (); ->elements will be inserted.
Comparable (I)
It has only one method
Public int compareTo (object obj).
Queue
If we want to represent a group of individual objects prior to processing.
All these interface representing a group of individual objects as key value pairs then we
should go for map interface.
Methods:
Offer () -> to add object.
Poll () -> to remove if empty it returns null.
Remove () ->to remove if empty it throws exception.
Peek () ->It shows the last element.
Element ()
DeQueue Methods:
addFirst () ->add object at first.
removeFirst () ->It removes first element.
get First() ->It returns the first element of queue.
addLast () ->It add object at last.
removeLast () ->It removes the last element.
getLast () ->It returns the last element.
Map
Map is not child interface of collection.
If we want to replace group of individual objects as key value pairs.
Both key and value are objects, Duplicate keys are not allowed but values can be duplicated.
If we want to represent a group of key value pairs according to sorting order of keys..
Default sorting -> comparable (I)
Customized sorting ->comparator (I)

3. REASON FOR CHOOSING THIS TECHNOLOGY

1. Compared to many of the other OO languages (i.e. Java, C# etc.), C++ has better support
for the functional programming style.

2. Good support for generic programming.

3. C++ is faster. No matter what you have heard, the overall speed of C++ applications (either
real or perceived) is greater than that of other languages.
4. Templates and generic programming without too much brain twisting. Templates and type
safety is very important. If C++ hasn’t had templates, it would not be used.

5. Direct interfacing with C and O/S routines.

6. Plethora of good libraries.

7. C++ is always the right choice for serious applications that can be re-compiled on multiple
platforms.

8. C++ is preferred choice of programmers all over the world when it comes to programming
for creating games.
4. LEARNING OUTCOME
5. GANTT CHART
 6. BIBLIOGRAPHY

WEBSITE:

www.edx.org

www.studytonight.com

www.tutorialspoint.com

SEARCH ENGINE:

www. Google.co.in

REFERENCES

1. Ashok N Kamthane, Object Oriented Programming .