My Java Notes

Java
Java is a technology and it has 2 things
1.programming language
2.platform
Note: java is not only programming language it is also a platform. Java programming
language used to develop apptions and services
Apption: an apption is a program in which we interact with on the desktop.
Types of apptions:
1.stand alonone apptions
2.distributed apptions
1.standalone apption:
A stand alone apption is an apption which runs on only one system
2.distributed apption:
A distributed apption is an apption which runs on two or more systems
Types of stand alone apptions:
1.console apptions:(character user interface (CUI))
2.window apptions(Graphical user interface(GUI)
console apptions:
a console apption is an apption in which we interact with commands by using keyboard

ex: command prompt, sql prompt…. Etc.
window apptions:
a window apption is an apption in which we interact with keyboard and mouse
Ex: Ms-word,Ms-excel, Ms-powerpoint….etc
Types of distributed apption:-
1.Web apptions
2.Enterprise apptions
Web apption: it is a distributed apptions which runs on web browser and web server.
Types of web apptions:
1.static web apptions
2.dynamic web apptions
1.Static web apption:
A static web apption is a web apption which resides in server and executes in browser
Static web apptions can be developed by using HTML, java script, VB script…etc
2. Dynamic web apptions:
A dynamic web apption is a web apption which resides in server and executes in server
only
dynamic web apptions can be developed by using Servlets, java server pages…etc
Enterprise apption:
An enterprise apption is a distributed apption which performs business functions.
Ex: ATM banking, Railway reservation system…etc
Services:
A service is a process and process is an instance of .exe file
Ex: Notepad Notepad
Notepad.exe
Services used by apptions to run under operating system.
Types of services:
1.window services
2. Web services
1.Window service: it is a service and it is used by window apption to run under operating
system
2. Web service: it is a method of communication b/w 2 electronic devices
Platform: it can be a software or hardware environment in which program runs
There are 4 java platforms:
1.javaSE
2.javaEE
3.javaME
4.javaFX
1.javaSE
It is the widely used java platform for developing console apptions, window apption and
static web apptions.
2.javaEE
It is a widely used java platform for developing dynamic web apptions, enterprise
apptions and services.
3.javaME
it is a platform designed for embedded systems. Embedded devices are industrial

controls, mobile phones, TV set-up boxes
4.javaFX:
It is java platform designed for rich internet apptions. Rich internet apptions means
which contains more graphics
JDK
JDK stands for Java Development Kit.It physically exists.It contains JRE + development
tools.
JRE
JRE stands for Java Runtime Environment. It is used to provide runtime environment. It
is the implementation of JVM. It physically exists. It contains set of libraries +
other files that JVM uses at runtime. Jre is part of jdk
JVM
JVM (Java Virtual Machine) is an abstract machine. It is a specification that provides
runtime environment in which java bytecode can be executed.
JVMs are available for many hardware and software platforms. JVM, JRE and JDK are
platform dependent because configuration of each OS differs. But, Java is platform
independent.
The JVM performs following main tasks:
Loads code
Verifies code
Executes code
Provides runtime environment
Declaration rules for a source file(.java)

A source file can have only one public class
A source file can have any no of non public classes.
If the source file contains public class then file neme must match with public class name
If the source file does not contain public class then no naming restriction to file name
If we define a class in side the package then then package statement must be declared at
first line in the source file.
Inside a source file, import statements must be declared between package statement and
class declaration.
Note: If there is no package statement then import statement must be declared at first
line.
Java notations : (java coding standards)

When ever we are writing the code it is highly recommended to follow coding
conventions the name of the method or class reflect the purpose of functionality
of that component
.
1.package & subpackage: all small letters. Sub packages are separated with( ) symbol
Ex: 1.java.lang
2.Java.awt.event
2.class and interface:
Usually class names are nouns, should starts with Upper case letter. If ti contains
multiple words every inner word should starts with upper case letterl. No space
between words
Ex: 1.String
2.StringBuffer
3.ArrayIndexOutOfBoundsException
Usually interface names are adjectives should starts with uppercase letter and if it
contains multiple words everyh inner word should starts with uppercase letter.
No space between the words
1.Serializable
2.Runnable
3.Cloneable
3.variable and method: second word onwards first letter of the word is capital. No space
between words
Ex.
1.empNo
2.netIncome
3.compareTo( )
4.toString
To compile:
javac filename.java
To:run:
Java classname
Temporary path setting:
C:\> set path=”%path%”.; C:\Program Files\Java\jdk1.5.0_21\bin;
Identifiers
A name in the program is an identifier it may be class name or method name,variable
name or label name.
Ex:
1) A java identifier is a sequence of characters, where each character may be a letter

from a-z or A-Z
or a digit form 0-9 or currency symbol $ or connecting punctuation – , if we are using any
other
symbol we will get Compile time error “IllegalCharacter”.
2) Identifier should not be starts with digit.
3) There is no length limit for java identifiers but it is not recommended to take more
than 15
length.
4) Java Identifiers are case sensitive
5.reserve words cannot be used as identifiers.
6.the names of predefined classes and interfaces can be used as identifiers but it is not
recommended.
Reserved Words
Some identifiers are reserved to associate some functionality or to represent values,
such type of reserved identifiers are called “ReservedWords”.
In java total 53 keywords are there. In this 50 key words and 3 reserved literals
Datatypes:
Datatype defines the type of value that can be stored in a particular variable.
It determines what value a variable can hold
Data types are used to specify the how much memory is allocated for
variables.
In java data types are devided into 2 types
1.primitive data types
2.reference data types
1.primitive data types:
There are 8 primitive data types in java and those are named by keywords.
Data type Size Range Default values
byte 1 -128 to 127 0
short 2 -32768 to 32767 0
int 4 -2147483648 to 2147483647 0
long 8 -231 to 231-1 0
float 4 -3.4e38 to 3.4e38 0.0
double 8 -1.7e308 to 1.7e308 0.0
char 2 0 to 65535 Single space character
boolean NA Not Appble False
Reference datatype:
Arrays,Strings,Classes, Interfaces
Literals:-
Literal is a constant value assigned to the variables.

Integral Literal
We can specify an integral literal in the following ways.
Decimal literals: allowed digits are 0 to 9
Octal literals: allowed digits are 0 to 7 but here literal value should be prefixed with
0(zero)
Hexadecimal literals: the allowed digits are 0 to 9, A- F (Both lower, Upper case) literals
should be prefixed with 0x or 0X
class Demo
public static void main(String arg[])

{
int x = 10;
int y = 010;
int z = 0x10;
System.out.println(x + "..." + y + "..." + z);
Note: By default every integral lateral is of int datatype
An integral literal is of long type should suffixing with l or L.
Floating – point literals

By default floating-point literals are double type we can specify explicitly as float type by
suffixing
with ‘f’ or ‘F’.
A. float f = 10.5; X C.E possible loss of precision
B. float f = 10.5f;
we can specify explicitly a floating point literal of double type by suffixing with d or D.
double d = 10.5D;
Boolean Literals
The only allowed values for boolean datatype are true, false.
1. boolean b = true;
character literal
A char literal can be represented as a single character with in single quotes.
Ex:
char ch = 'a';
we can represent a char literal by using it’s Unicode value. For the allowed Unicode
values are 0 to
65535.
Ex:
char ch = 97;
System.out.println(ch);  O/P: a
String literal
A sequence of character with in double quotes is String literal.
String s = "Java";
Variable:
A variable is a container which contains data
A Java variable is a piece of memory that can contain a data

value. every variable has a data type .
Declaration: datatype variable;
Ex: int a;
Assignment:
Variable=literal;
Ex a=10;
Initialization:
Datatype variable=literal;
Ex:
Int x=10;
Note: primitive type variable stores data where as reference variable stores hashcode
Object Oriented Programming:
Java is a object oriented programming language.
A language that supports all the principles of Object Oriented programming is known as
object oriented programming language.
Object Oriented Principles:
1.Encapsulation
2.Abstraction
3.Inheritance
4.Polymorphism
To use the above principles in a java programming we need following language

constructs.
1.Class
2.Object
1.Class:
A class is a collection of variables and methods.
“A class is a way of binding the data and associated methods in a single unit”.
Any JAVA program if we want to develop then that should be developed with respect
class only i.e., without class there is no JAVA program.
Syntax:
class class_name
Datatype variable1;
Datatype variable2;
--------
returntype method_name(arguments list)
---method definition
Note: class will not occupy memory where as file occupies memory.
2.Object:
An instance of a class is called object.
In order to store the data for the data members of the class, we must create an object.
Instance (instance is a mechanism of allocating sufficient amount of memory space for

data members of a class) of a class is known as an object.
Class variable is known as an object.
Syntax-1 for defining an OBJECT:
classsname objectname = new classsname();
Ex: Demo ob=new Demo( );
“ob” is called as Object name or Reference variable or Object Refrence
“new” is called dynamic memory allocation operator. Because it allocates the memory at
runtime.
Emp e1=new Emp( );
e1 Emp object
eno
data
Hashcode
Reference variable
Each and every object occupies memory.
Every object reference also occupies memory

Object contains data where object reference contains hashcode
hash code is an unique id number allocated to an object by JVM. The
hashcode of a Java Object is simply a number, it is 32-bit signed int
Types of variables:
Instance variables
Class variables.
Local variables
Instance variables:
If the value of the variable is varied from object to object such
type of variables are called instance variable
The scope of the instance variable is exactly same as the object
because instance variables are created at the time of object
creation and will be destroyed at the time of object
destruction
Instance variables should be declared inside the class and out
side the method and constructors.
Instance variables cannot be accessed from static area directly
we can access by using object or object reference
A variable which is defined as a member of a class is know as an
instance variable
Memory allocated to instance variable ever an object is created
Instance variables are stored in heap area.
Separate copy of instance variable exist for every instance
There are two ways to access instance variables
1.by using object
2.by using object reference
Use object to access instance variable if it is required only one
time
Use object reference to access instance variable if it is required
more than one time
For instance variables it is not required to perform
initialization explicitely , jvm will provide default values
Static variables/class variables:

A variable which is defined inside a class and out side the
methods and constructros with static modifier is called as
static variable or class variable.
Memory allocated to class variables when class is loaded .
Class variables are stored in method area.
The value of static variable is not varies from object to object,
for all the objects only one copy of static variable is
available. Static variables are called as class level variables
Static variables are created at the time of class loading and
destroyed at the time of class is unloading. Hence the scope
of the static variable is exactly same as the scope of the
class.
Static variables are created at the time of class loading i.e.(at
the beginning of the program) hence we can access from
both instance and static area directly
For the static variables it is not required to perform
initialization explicitely compulsory jvm will provide
default values
There are 4 ways to access class variables
1.directly
2.by using class name
3.by using object
4.by using object reference
Last two ways are not recommended
Access class variables directly if they are present in the same
class.
Use class name to access the static variables if they are present
in the different class.
If we perform any changes to the static variables using one
object it will reflect in remaining objects also because
single copy will be shared by all the objects
Local variables:
To meet temporary requirements of the programmer some
times we have to create the variables inside the method or
a block or constructors . such type of variables are called
as local variables
Memory is allocated to local variables when ever a
method/block/constructor is called
Local variables are stored in stack area of the memory
Note: local variables cannot be static in java.
There is only one way to access the local variables i.e. directly.
For the local variable jvm wont provide any default values,
compulsory we should perform initialization explicitely,
before using that variable.
The only appble modifier for local variables is final.
Arrays:
array is a collection of similar type of elements that have contiguous memory location.
Java array is an object the contains elements of similar data type.
An array is an indexed collection of fixed number of homogenous data elements
The main advantage of arrays is we can represent a group of values with single name
hence readability of the code will be improved
The main limitation of arrays is they are fixed in size.i.e once we constructed an array
there is no chance of increasing or decreasing bases on our requirement
Array Declaration,Construction &Initialization
Array Declaration:
The following are the ways to declare an array.
int [] a;
int a[];
int [] a;
At the first time of declarations we are not allowed to specify the size. Violation leads to
compile time
Declaring Multidimensional Arrays
int[ ][ ] a;
int a[][];
int [][]a;
int[] a[];
int[] []a;
Construction of Arrays
Single Dimension : Arrays are internally implemented as object hence by using new
operator we can construct an array. Compulsory at the time of construction we
should specify the size otherwise compile time error.
int[] a = new int[10];//valid
int[] a = new int[];//invalid
It is legal to have an array with size 0 there is no compile time error or run time error.
int[] a = new int[0];
If we are specifying array size with some –ve integer we will get run time exception
saying NegativeArraySizeException.
int[] a = new int[-10];
The only allowed Data type to allow the size are byte, short,char,int. if we are using any
other datatype we will get a compile time error.
int[] a1 = new int[100];
int[] a = new int[10L]; // compile time error: possible loss of precision found: long
required: int
int[] a = new int[10.5];// compile time error

int[] a = new int[true]; // compile time error: Incompatible types found : boolean
required:int.
Multi Dimension: In java multidimensional arrays are implemented as single dimension

arrays. This approach improves performance with respect to memory.
int[][] a = new int[3][2];
int[][] a = new int[4][]
a[0] = new int[1];
a[1] = new int[2];
a[2] = new int[4];
a[3] = new int[3];
Initialization of arrays
Once we created an array all it’s elements initialized with default values. If we are
providing any explicit initialization then default values will be overridden with
our provided values.
Example:1
System.out.println(a[0]);//Output: 0
System.out.println(a);//O/P: [I@12dacd1
when ever we are trying to access an array with int index which is not in valid range
then we will get runtime exception saying “ArrayIndexOutOfBoundsException”
but there is no compile time error.
If we are trying to access an array index with the following datatype we will get
compile time error.
float, double, long, boolean.
Declaration Construction and Initialization in a single line

int []a;
a = new int[3];
a[0] = 10;
a[1] = 20;
a[2] = 30;
All the above statements we can replace with a single line as
follows.
int[] a = {10,20,30};
If we want to use the above shortcut technique compulsory we
should perform declaration,construction initialization in a
single line only. If we are dividing into 2 lines we will get
compile time error.
int[][] a = {{10,20},{30,40,50}};
int[][][] a = {{{10,20},{30,40}},{{50,60},{70,80}}};
Array length:
length is a final variable which is used to find the length(no of

characters of an array)
Anonymous Arrays
Some times we can declare an array with out name also such
type of arrays are called anonymous arrays.
The main objective of anonymous arrays is just for temporary
usage. We can create an anonymous arrays as follows.
new int[]{10,20,30,40}
Package
package in java is an encapsulation mechanism to group related classes and interfaces
into a single
module. The main objective of package is to resolve naming conflicts.
There is universally accepted convention to name the package i.e to use internet domain
name in
reverse.
a package is a collection of subpackage, classes , interface
java library organised in the form of packages
it is an encapsulation mechanism to group related classes and interfaces into a single

module
the main purpose of packages are
1.to resolve naming conflicts
2.to provide security to the classes and interfaces so that out side person
cant access directly
3.it improves modularity of the apption
there is one universally accepted convension to name packages i.e. to use
intertent domain name in reverse
Compile:
javac –d . Test.java
-d means destination to place generated class files “.” means current working directory.
Generated class file will be placed into corresponding package structure.
If the specified package structure is not already available then this command itself will
create the required package structure.
As the destination we can use any valid directory.
If the specified destination is not available then we will get compile time error.
How to execute package program:java com.rajusoft Test

package com.rajusoft;
class Test
System.out.println("package name");
The first non-comment statement in any java source file is package statement.
import Statement
the main objective of import statement is it acts as typing shortcut.
1) implicit class import.
2) explicit class import.
Explicit class import:
Example: Import java.util.ArrayList
This type of import is highly recommended to use because it improves readability of the
code.
Implicit class import:
Example: import java.util.*;
It is never recommended to use because it reduces readability of the code.
class MyArrayList extends java.util.ArrayList
The code compiles fine even though we are not using import statements because we
used fully qualified name.
Whenever we are using fully qualified name it is not required to use import statement.
Similarly whenever we are using import statements it is not require to use fully qualified
name.
static imports
The main objective of static imports is to import static members of a particular class
Without static import:
class Test
public static void main(String args[]){
System.out.println(Math.sqrt(4));
System.out.println(Math.max(10,20));
System.out.println(Math.random());
}}
With static import:
import static java.lang.Math.*;
class Test
System.out.println(sqrt(4));
System.out.println(random());
System.out.println(max(10,20));
}
class modifier
when ever we are writing our own classes compulsory we should provide information about
our class to the JVM like.
1) child class creation is possible or not
2) Instantiation is possible or not
3) Whether we can access this class from any where
We can specify this information by declaring the corresponding modifier.
The only appble modifier for the top level classes are
public, <default>, final, abstract, strictfp
For the inner classes the appble modifiers are
public, <default>, final, abstract, strictfp, private, protected, static
public classes
If a class declared as the public then we can access that class from any where.
<default> classes
If a class declared as default then we can access that class only in the current package.
<default>
access is also known as package level access.
abstract
abstract is the modifier appble only for classes and methods i.e we can’t use abstract for
variables.
If we don’t know about implementation still we are allowed to declare methods with
abstract
modifier.
abstract method should have only declaration but not implementation hence abstract
method
declaration should ends with ;(semicolon)
child class is responsible to provide implementation for abstract methods.
abstract never talks about implementation, if any modifier talks about implementation it is
considered as illegal combination with abstract.
Hence the following 6 combinations are illegal.
abstract final
synchronized
native
static
strictfp
private
If we don’t want instantiation for any class such type of classes we have to declare with
abstract
modifier. i.e for abstract classes instantiation is not possible
If a class contain at least one abstract method then the corresponding class should be
declared as
abstract otherwise C.E.

Even though class doesn’t contain any abstract method still we can declare that class with
abstract
modifier.i.e abstract class can contain zero no of abstract methods.
If we are creating any child class for abstract class then compulsory we should provide
implementation for all abstract methods of parent class other wise the child class also
should be
declared as abstract
final
final is the modifier appble for classes, methods and variables.
If a method is not allowed to override in the child class then we should declare that method
as ‘final’.
i.e for the final methods overriding is not possible.
for any class if we are not allow to create child class, such type of classes we have to declare
with
final i.e for final classes inheritance is not possible.
final method should not be overridden but we should override abstract method to provide
implementation. Hence final & abstract combination is always illegal for both method and
class
public abstract final void m1(){}X
Strictfp
Java strictfp keyword ensures that you will get the same result on every platform if
you perform operations in the floating-point variable. The precision may differ
from platform to platform that is why java programming language have
provided the strictfp keyword, so that you get same result on every platform.
abstract and strictfp is a legal combination for the classes(Illegal for the methods)
member modifiers
public members
we can access public members from any where but the corresponding class must be visible.
<default> members
If a member declared as a default we can access that member only in the current package.
private members
If a member declared as private we can access that member only in the current class.
protected members
If a member declared as protected then we can access that member from any where with in
the
current package and only in child classes from outside package.
We can access protected members from outside package only in child class.
And we should use child class reference only. i.e parent class reference is not allowed to
access protected members from
outside package violation leads to C.E but in the current package we can access protected
members
either by using parent class reference or by child class reference.
The Most Restricted Modifier is Private.
The Modifier Which provides wide range of access is Public .
Public > Protected > Default > Private
Recommended Modifier for data members is Private.

And for methods is public .
Final Variables
For the Static and instance variables no need to perform initialization, JVM Will Provide
default
initialization.
For the local variables compulsory we should perform initialization before using.
Final Instance Variables

For the final instance variables JVM won’t provide any default values, compulsory we should
perform initialization before completion of constructor.
The following are the places to perform this
1) At the time of declaration:.
final int i = 0;
2) Inside instance initialization block
3) Inside constructor
Final static Variables

For the final static variables compulsory we should perform initialization.
1) At the time of declaration
final static int i = 0;
2) Inside static blocks
Final local Variables

Before using a local variable(whether it is final or non-final) we should perform
initialization. If we
are not using local variable then no need of perform initialization even though it is final.
static Modifier
static is the modifier is appble for methods and variables.
we can’t declare top level classes as static but inner classes can be declares as static( static
nested class).
Instance variables(methods) can’t be accessed from static area directly, But Static members
can be accessed from any where.
abstract and static combination is illegal for methods.
Overloading is possible for static methods.
overriding is not appble for static methods but seems to be overriding is possible, but it is
method hiding.
native
native is the modifier appble only for methods
we can’t declare classes and variables as native.
The methods which are implemented in non-java are called “native methods” or “foreign
methods”.
Synchronized
It is a keyword appble only for methods and blocks. We can’t declare variables and classes
with
synchronized keyword.
If a method declared as synchronized at a time only one thread is allowed to execute on the
given
object. Hence the main advantage of synchronized keyword is we can overcome data
inconsistency
problem.
Use of synchronized keyword may effect performance of the system.

Transient Modifier
transient keyword is used along with instance variables to exclude them from serialization
process.
Transient is the keyword appble only for variables. i.e we can’t apply transient for
methods and classes.
While performing serialization if u don’t want to save the value of a particular variable, that
variable we have declared with transient keyword.
At the time of serialization, JVM ignores the value of transient variable and saves it’s default
value.
i.e Transient means not to serialize.
Declaring a static variable as transient there is no impact.
Similarly declaring final variables with transient keyword creates no impact.
VolatileModifier
Volatile is the keyword appble only for variables. We can’t declare methods and classes with
volatile modifier.
If the value of a variable keep on changing then we have to declare that variable as volatile.
volatile and final is illegal combination for the variables.
Interfaces
1) Introduction.
2) Declaring Interface.
3) Interface Methods.
4) Interface variables.
5) Naming conflicts in interface.
6) Marker/Tag interface.
Interface is similar to class which is collection of public static final variables (constants) and
abstract methods.
The interface is a mechanism to achieve fully abstraction in java. There can be only abstract
methods in the interface. It is used to achieve fully abstraction and multiple
inheritance in Java.
properties of Interface
It is implicitly abstract. So we no need to use the abstract keyword when declaring
an interface.
Each method in an interface is also implicitly abstract, so the abstract keyword is

not needed.
Methods in an interface are implicitly public.
All the data members of interface are implicitly public static final.
How interface is different from class ?

You can not instantiate an interface.
It does not contain any constructors.
All methods in an interface are abstract.
Interface can not contain instance fields. Interface only contains public static final
variables.
Interface is can not extended by a class; it is implemented by a class.
Interface can extend multiple interfaces. It means interface support multiple

inheritance
A class uses the implements keyword to implement an interface.
The allowed modifiers for interface are
public
abstract
strictfp
<default>
When ever we are implementing an interface method compulsory we should declare that
method as
public otherwise compile time error.
extends vs implements
A class can extends only one class at a time. But an interface can extends any no of interfaces
simultaneously.
But an interface can’t implement another interface.
Difference between Abstract class and Interface
Abstract class Interface
It is collection of abstract method and

1 It is collection of abstract method.
concrete methods.
3 It does not support multiple inheritance. It support multiple inheritance.
Abstract class is preceded by abstract

4 It is preceded by Interface keyword.
keyword.
5 Which may contain either variable or Which should contains only constants.
constants.
The default access specifier of abstract There default access specifier of interface
6
class methods are default. method are public.
These class properties can be reused in

These properties can be reused in any other
7 other class using extends
class using implements keyword.
keyword.
Inside abstract class we can take Inside interface we can not take any
8
constructor. constructor.
For the abstract class there is no

For the interface it should be compulsory to
restriction like initialization of
9 initialization of variable at the time of
variable at the time of variable
variable declaration.
declaration.
For the interface variable can not declare

There are no any restriction for abstract
10 variable as private, protected,
class variable.
transient, volatile.
There are no any restriction for abstract For the interface method can not declare
11 class method modifier that method as strictfp, protected, static,
means we can use any modifiers. native, private, final, synchronized.
interface Methods
Every Interface method is by default public and abstract whether we r declaring or not.
As the interface method are by default public and abstract, we r not allowed to use the
following
modifiers.
private
protected
static
final
native
strictfp
synchronized.
Interface variables
An interface can contain variables also every interface variable is by default public static
and final
whether we r declaring or not.
As interface variables already public static and final we r not allowed to declare with the
following
modifiers.
private, protected, volatile, transient.
For the interface variables compulsory we should perform initialization at the time of
declarations
only.
Marker Interface
An interface that have no member is known as marker or tagged interface.
By implementing an interface if our objects will get some ability, Such type of interfaces are
called
“marker” or “taginterface”.
Ex:
Serializable, Clonable interfaces are marked for some ability.
OO CONCEPTS:
Data Hiding
The data should not go out directly i.e outside person is not allowed to access the data this is
nothing but
“Data Hiding”.
The main advantage of data hiding is we can achieve security.
By using private modifier we can achieve this.
Abstraction
Hiding implementation details is nothing but abstraction. The main advantages of
abstraction are we can achieve security as we r not highlighting internal
implementation.
Enhancement will become easy. With out effecting outside person we can change our
internal
implementation.
Hiding of data is known as data abstraction. In object oriented programming language this
is implemented automatically while writing the code in the form of class and object.
It improves maintainability.
Encapsulation
is a process of wrapping of data and methods in a single unit is called encapsulation.
Encapsulation is achieved in java language by class concept.
If a class follows data hiding and abstraction such type of class is said to be ‘Encapsulated’
class.
Encapsulation = Data Hiding + Abstraction
Ex:
class Employee
{
private String name;
public String getName()
return name;
public void setName(String name){
this.name=name;
class Demo
public static void main(String[] args)
Employee e=new Employee();
e.setName("Harry");
System.out.println(e.getName());
The main advantage of using of encapsulation is to secure the data from other methods, when
we make a data private then these data only use within the class, but these data not
accessible outside the class.
. i.e hiding data behind methods
is the central concept of encapsulation.
The main advantages of encapsulation are security, enhancement, maintainability.

Relationships in Java
IS – A RelationShip
In Is-A relationship one class is obtaining the features of another class by using inheritance
concept with extends keywords.
Also known as ‘inheritance’.
Creating a new class from an existing class is called as inheritance
By using extends keyword we can implement inheritance.
The main advantage is reusability.
class Parent
public void methodOne()
{}
class Child extends Parent
public void methodTwo()
{}
Class Test
Public satic void main(String args[ ])

{
Parent p=new Parent();
p.methodOne();
p.methodTwo();
Child c=new Chile();
c.methodOne();
c.methodTwo();
Parent p1=new Child();
P1.methodOne();
P1.methodTwo();
Child c1=new Parent();
Memory allocated to both super class and sub class members when ever object is created to
sub class
1) Whatever the parent has by default available to the child but whatever the child has by
default not available to the parent. Hence on the child reference we can call both parent
and child class methods. But on the parent reference we can call only methods available
in the parent class and we can’t call child specific methods.
2) Parent class reference can be used to hold child class object but by using that reference
we can call only methods available in parent class and child specific methods we can’t
call.
3) Child class reference cannot be used to hold parent class object.

Multiple inheritance:
Having more than one Parent class at the same level is called multiple inheritance with respect to
classes
Any class can extends only one class at a time and can’t extends more than one class
simultaneously hence java won’t provide support for multiple inheritance with respect to classes.
We can achieve multiple inheritance in java by using interfaces.
In java hierarchy of classes Object is class is the super class of all other classes(user defined or
predefined classes)
If our class doesn’t extends any other class then only our class is the direct child class of
object.
HAS – A RelationShip
In Has-A relationship an object of one class is created as data member in another class the
relationship between these two classes is Has-A.
Ex:
class A
public void show()
===
}
}
class B
A ob=new A();//this statement establishes the has-A relation ship
ob.show();
Also known as Composition or Aggregation .
There is no specific keyword, but most of the cases we can implemented by using new
keyword.
Main advantage is reusability.
Drawback:
HAS – A relationship increases dependency b/w components and creates maintainability
problems.
Method Signature
In java method signature consists of method name and arguments list( including order also)
In java return type is not part of the method signature.
Compiler uses method signature to resolve method calls.
Two methods with the same signature are not allowed in any java class, violation leads to
compile time error.
Public int calculateSalary(int basic,float da)
Public void calculateSalary(int basic,float da)// compile time error because both methods
are having //same signature
{
‘this’ Key word:
It is called as reference variable because it refers an object . it always refers current object
public class Demo {
int x=5;
void display()
System.out.println(x);// implicitely System.out.println(this.x);
show();// implicitely this.show();
void show()
System.out.println("this is show method");
}
public static void main(String[] args) {
Demo o=new Demo();
o.display();
class Employee {
int empNo;//instance variable
String empName;//instance variable
Employee(int eno,String name)// local variables
empNo=eno;
empName=name;
Employee getDetails()//when ever method return type is class it indicated that method
will return an object of that class
return this;//"this" statement returns the current object
}
public static void main(String args[])
Employee e1=new Employee(101, "ramesh");
Employee e3=e1.getDetails();
System.out.println(e3.empName+" "+e3.empNo);
This is key word is explicitly required to access instance variables when ever both instance
variable and local variable names are same.
public class Employee {

int empId;
String empName;
Employee(int empId ,String empName)
{
this.empId=empId;
this.empName=empName;
}
Employee e1=new Employee(101, "raj");
System.out.println(e1.empId);
System.out.println(e1.empName);
}
By default this referece is prefixed when we access instance variables and methods.
We cannot use this keyword in a static context(static method,static block)
public class Demo {
Demo()
System.out.println("default constructor..") ;
Demo(String s)
this();
System.out.println("parameterised constructor..") ;
}
Demo o=new Demo("hello");
Constructors:
Constructor is a special method which has the same name as the class name .
Constructor does not have any return type
Constructor is called automatically when ever an instance is created for a class .
Constructors are used to initialize the instance variables of a class.
Constructors are of two types
1.default constructors
2.parameterised constructors
public class Demo {

public Demo()
System.out.println("this is default constructor");
public Demo(String s)
System.out.println(s);
new Demo();
new Demo("hello");
this() : it is used to call default constructor of a current class
this(…):it is used to call parameterised constructor of a current class

note : this() and this(…) must be the first statements in a constructors
note: the java compiler provides one default constructor if the class does not contain any
other constructor
in the below example the instance variables are directly initialized.
Use constructors to assign different values to the instance variables.
class Emp
int empNo=101;
String empName="suresh";
public class Demo{
Emp e1=new Emp();
Emp e2=new Emp();
System.out.println(e1.empNo +" "+e1.empName+" ");
System.out.println(e2.empNo +" "+e2.empName+" ");

}
Super keyword
It is called as reference variable or object reference because it refers super class

members(data,methods)
It is explicitly required to access super class members when ever super class members and
sub class member names are same
class A
int x=5;
class B extends A
int x=10;
void print()
int x=15;
System.out.println(x);
System.out.println(this.x);
System.out.println(super.x);
B ob=new B();
ob.print();
Note: static method does not refer “this” and “super” key word in any way (explicitely or
implicitly)
super() : it is used to call default constructor of a super class. This statement is provided by
java compiler in every constructor
super(…):it is used to call parameterised constructor of a super class.This statement is used

by programmer to call parameterized constructor of a super class.
Note: super() and super(…) must be the first statements in a constructor
class A
A()
{
System.out.println("super class constructor");
class Demo extends A
Demo
()
Super();
System.out.println("this is sub class constructor");
Demo ob=new Demo();
Block:
The group of statements between open and close flower brackes{ } is called block
One class can have any number of blocks. All the blocks are executed from top to bottom
order before constructor , when ever an object is created.
public class Demo{
System.out.println("block1");
Demo()
System.out.println("this is a default constructor");
System.out.println("block2");
{
new Demo();
A block is called as initialization block because it is used to initialize the instance variables
of the class
Static block:
A block with static keyword is called static block
One class can have any number of static blocks. All the blocks are executed from top to
bottom order before constructor , when ever a class is loaded
A static block is called as static initialization block because it is used to initialize the static
variables of the class Static blocks are used in real time to load the libraries
Polymorphism:
The ability to take more than one form is called polymorphism
Poly means many, morph means form
There are two types of polymorphism
1.compile time polymorphism(static binding)
2.run-time polymorphism(dynamic binding)

1.compile time polymorphism:
Binding of method call statement with method definition is done at compile time only is
known as compile time polymorphism
Ex: method overloading
OverLoading
Whenever same method name is exiting multiple times in the same class with different number
of parameter or different order of parameters or different types of parameters is known as
method overloading.
In method overloading the return type of methods can be same or different.
The overloading method resolution is the responsibility of compiler based on reference

type and method arguments. Hence overloading is considered as compile-time
polymorphism or EarlyBinding.
Note: The scope of overloading is within the class.
We can overload main() method
class Demo
void add (int a,int b)
System.out.println(a+b);
void add (int a,int b,int c)
System.out.println(a+b+c);
}
Demo ob=new Demo();
ob.add(14, 15, 16);
ob.add(10,20);
2.Runtime polymorphism:
Binding of method call statement with method definition is done at runtime is known as
runtime polymorphism
Ex: method overriding.
Overriding
If two or more methods with the same name and with the same parameters list then it is
said to be method overriding
What ever the parent has by default available to the child class through inheritance,
If the child class is not satisfied with the parent class implementation then the child is
allowed to overwrite that parent class method to provide it’s own specific
implementation, this concept is nothing but “overriding”.
Note: Without Inheritance method overriding is not possible.
Methods cannot be overridden in a same class.

class A
void show()
System.out.println("A class ");
void print()
System.out.println("print method");
class Demo extends A
void show()
System.out.println("B class ");
void display()
System.out.println("display method");
}
Demo ob=new Demo();
ob.show();
ob.print();
ob.display();
Overriding method resolution will take care by JVM based on runtime Object. Hence
overriding is
considered as runtime polymorphism or dynamic polymorphism or latebinding.
Difference between method overloading and method overriding
Method overloading Method overriding
1.if two or more methods with the same 1. if two or more methods with the same
name and different parameters lists name and with the same parameters
then it is said to be method lists then it is said to be method
overloading overriding
2. methods can be overloaded within the 2. methods cannot be overridden within

same class the same class because of ambiguity
3.methods can be overloaded in 3.method overriding always needs

inheritance also inheritance
4. in method overloading return type can 4. in method overriding return type must
be same be same
Or different Except co-variant return type

5. in method overloading access modifiers 5. in method overriding access modifiers
can be same or different can be same or less restrictive
6. final methods can be overloaded 6. final methods cannot be overridden.

Because final modifier is used to
prevent method overriding
7. static methods can be overloaded 7. static methods cannot be overridden

because static members are not a
part of an object
8. private methods can be overloaded 8.private methods cannot be overridden.

Because private members cannot be
inherited
Co-variant return type:
Java allows sub class type as a return type while overring a method this is known as co-
variant return type.
In overriding the return types must be same but this rule is appble only until 1.4 version but
from 1.5 version onwards co-variant return types also allowed. i.e the child class method
return type
need not to be same as parent class method return type it’s child class also allowed.
Ex:
Parent : Object(covariant returntype).
Child : String, StringBuffer, Object…..
Parent : String
Child : Object X
Because String to Object is not a covariant.
A static method can’t be overridden as non-static. Similarly a non-static method can’t be

overridden as static method.
Ifboth parent and child class methods are static then there is no compile time error or run
time error
it seems that overriding is happened but it is not overriding this concept is called “method
hiding”.
All the rules of method hiding are exactly similar to overriding, except both methods
declared as
static.
In the case of method hiding method resolution will take care by compiler based on
reference
class P
public static void m1()
System.out.println("parent method");
class C extends P
public static void m1()
System.out.println("child method");
class Test

{
P p = new P();
Case1: p.m1(); //parent method
C c = new C();
Case2: c.m1(); //child method
P p1 = new P();
Case3: p1.m1(); //parent method
Execution priority:
1.static variables are initialized
2.static blocks are executed
3.main method is called
Without using a main method still we can execute a program
class StaticDemo
static
System.out.println("Hello....I can print ");
System.exit(0);

{
Typecasting
converting one data type to another either implicitly or

explicitly.
Java supports two types of castings – primitive data type
casting and reference type casting.
Reference type casting is nothing but assigning one Java
object to another object.
1. Implicit casting
A data type of lower size is assigned to a data type of higher size. This is done implicitly by the JVM.
The lower size is widened to higher size. This is also named as automatic type
conversion.
int x = 10; // occupies 4 bytes
double y = x; // occupies 8 bytes
System.out.println(y); // prints 10.0
2. Explicit casting
A data type of higher size cannot be assigned to a data type of lower size. This is not done
implicitly by the JVM and requires explicit casting; a casting operation to be performed
by the programmer. The higher size is narrowed to lower size.
double x = 10.5;
int y = (int) x;
General syntax of typecasting
A b=(c) d;
Upcasting and Downcasting:
Assigning an object or reference variable of subclass type( child class obeject) to super class
type is known as upcasting
Upcasting done by system implicitely
Ex: 1)A ob=new B();
2)B ob1= new B();
A ob2=ob1;
Downcasting
Assigning an object or reference variable of superclass type to subclass type is known as
downcasting
Downcasting must be done by programmer explicitely
Downcasting always need upcasting
A ob1=new B();
B ob2=(B) ob1;
String handling:
There are four string handling classes are available in java to handle strings
1.java.lang.String
2.java.lang.StringBuffer
3.java.lang.StringBuilder
4.java.util.StringTokenizer
Note:java.lang is a default package which is imported automatically in every java program
String:-
String is a final class it is present in java.lang package.
String is nothing but a group of characters or character array.
Once we are creating String object it is not possible to do the

modifications on existing object called immutability nature.
In String class .equals() is used for content comparision.
Every string literal itself is an object of String class

Once we created String objects we are not allowed to perform any changes in the existing
object. If u r
trying to perform any changes with those changes a new String object will be created this
behavior is
nothing but ‘immutability’ Of the String Objects.
There are two ways to create the strings in java
1.String s1=”hello”;
2.String s2=new String(“welcome”);
First statement creates one String object in string constant pool. Where as second statement
creates two objects , one in string constant pool and the another one out side the
pool.(on heap)
When ever an object or object reference is passed in system.out.println()then implicitely

toString() is called
toString() is present in Object class and it is overridden in String class
An Object class toString() method always returns ClassName@Hashcode in hexa decimal

format.
Where as the String class toString() method always returns the contents of the string object
public class Demo{
String s=new String("hello");

Demo ob=new Demo();
System.out.println(ob);
The object class toString method can be overridden by the programmer to change the
definition
Note: java.lang.String is a final class and it cannot be inherited
public class Demo{
public String toString()
return "welcome";
Demo ob=new Demo();
}
Java.lang.String
Constructors:
1.String ();
2.String (String);
Constructor-1 is used for creating empty string object.
Constructor-2 is used for creating a String object by taking another string as a parameter.
3.public String(char[]);
4.public String(char[], int, int);//first int indicates the starting index and second int
represent no of characters from the starting index
The above two constructors are used to convert the character array into a String
5.public String(byte[]);
6. public String(byte[], int, int);
The above two constructors are used to convert the byte array into a String
public class Demo{
String s1=new String();
String s2=new String("hello");
char ch[]={'w','e','l','c','o','m','e'};
String s3=new String(ch);
String s5=new String(ch,3,4);
byte b[]={65,66,67,68};
String s4=new String(b);
System.out.println(s1);//prints nothing(empty string object)
System.out.println(s2);
}
Methods:
1.public int length();
Returns the length of this string.(no of characters present in the

given string)
2.public char charAt(int);
Returns the char value at the specified index.
3. public byte[] getBytes();
it is used to convert the given String into bytes array
4.public boolean equals(Object);
Compares this string to the specified object(string)
5.public boolean equalsIgnoreCase(String);
Compares this String to another String, ignoring case considerations.
6.public String concat(String);

Concatenates (adds) the specified string to the end of this string.
7.public String toLowerCase();
converts the given string to the lower case
8. public String toUpperCase();
converts the given string to the upper case
9. public String trim();
it is used to remove the extra spaces at the beginning of the string and at the end of the
string
10. public char[] toCharArray();
it is used to convert the given string into the character array
11. public String subString (int start);
is used for obtaining the characters from specified position to end character
position.
12. public String subString (int start, int end);
is used for obtaining those characters by specifying starting position to ending
position.
class Demo
String s1=new String("welcome");
int n= s1.length();
System.out.println("the length of the string is: "+n);
char ch=s1.charAt(3);
System.out.println("the character at 3rd location: "+ch);
byte b[]=s1.getBytes();
for(byte c:b)
System.out.println(c);
String s2=new String("welcome");
boolean comp=s1.equals(s2);
if(comp)
System.out.println("both the strings are same:");
else
System.out.println("both the strings are not same:");
String s3=new String("WELCOME");
boolean comp2=s1.equalsIgnoreCase(s3);
if(comp2)
System.out.println("both the strings are same:");

else
System.out.println("both the strings are not same:");
String s4=new String("to java");
String s5=s1.concat(s4);
String s6=new String (" hello to all ");
System.out.println(s6.trim());
char ch1[]=s2.toCharArray();
for(char temp:ch1)
System.out.println(temp);
System.out.println(s6.substring(8));
equals() method of java.lang.String compares the contents of the String object
equals() method of java.lang.Object class compares the hascode of the reference variable
“ == ” operator compares the hashcode
class Demo
String s1=new String("Hello");

String s2=new String("Hello");
System.out.println(s1.equals(s2));
System.out.println(s1==s2);
StringBuffer class:
Whenever we create an object of StringBuffer we get 16 additional characters memory
space. Hence an object of StringBuffer is mutable object.
StringBuffer API:
1. StringBuffer ()
2. StringBuffer (String)
Constructor-1 is used for creating an object of StringBuffer whose default capacity is 16

additional characters memory space.
For example:
StringBuffer sb=new StringBuffer ();
System.out.println (sb.capacity ());
Constructor-2 is used for converting String object into StringBuffer object.
For example:
String s=”HELLO”;
StringBuffer sb=new StringBuffer (s);
System.out.println (sb.capacity ());
System.out.println (sb.length ());
Instance methods:
1. public int length ();
This method is used for determining the length of the string.
2. public int capacity ();
This method is used for determining the capacity of StringBuffer object. Capacity of
StringBuffer object is equal to the number of characters in the StringBuffer plus 16
additional characters memory space.
3. public StringBuffer reverse ();
This method is used for obtaining reverse of source StringBuffer object.
4. public void append (String);
This method is used to append string data at the end of source StringBuffer object.
5. public StringBuffer delete (int start, int end);
This method is used for removing the specified number of characters from one position to
another position.(in between characters will be deleted from starting index to the ending
index)
note : ending index is not included
ex:
StringBuffer sb=new StringBuffer("welcome");
System.out.println (sb.delete(2, 5));// weme
public StringBuffer replace (String, int, int);
ex:
System.out.println (sb.replace(1, 6, "he"));//whee
This method is used for replacing the string into StringBuffer object form one specified
position to another specified position.
7. public StringBuffer insert (String, int,);
This method is used for inserting the string data from one specified position to another
specified position.
Ex:

System.out.println (sb.insert(2, "hello"));
Difference between String and StringBuffer class:
String StringBuffer
An Object of String class is immutable An Object of StringBuffer class is mutable
Methods of String class are not Methods of StringBuffer class are

synchronized synchronized
String class overrides the equals() method StringBuffer class does not overrides the
of Object class. equals() method of Object class.
public class Demo{
public static void main(String args[]){
String s1=new String("Taj");
String s2=new String("Mahal");
s1.concat(s2);
StringBuffer sb1=new StringBuffer("Taj");
StringBuffer sb2=new StringBuffer("Mahal");
sb1.append(sb2);
System.out.println(sb1);
}}
StringBuilder
Java StringBuilder class is used to create mutable (modifiable) string. The Java
StringBuilder class is same as StringBuffer class except that it is non-
synchronized. It is available since JDK 1.5.
Important Constructors of StringBuilder class
StringBuilder(): creates an empty string Builder with the initial capacity of 16.
StringBuilder(String str): creates a string Builder with the specified string.
StringBuilder(int length): creates an empty string Builder with the specified capacity
as length.
Difference between String, StringBuffer,StringBuilder:
String StringBuffer StringBuilder
Immutable Mutable mutable
Not synchronized synchronized Not synchronized
String tokenizer:
It allows an apption to break a string into tokens(words)
Constructor:
Public StringTokenizer(String);
Methods:
public boolean hasMoreTokens();
this method returns true if the next token is present other wise it returns false
public String nextToken();
it returns current token and moves the cursor to the next token
public int countTokens();
it returns number of tokens
import java.util.StringTokenizer;
public class Demo{
String s1=new String("welcome to java programming");

StringTokenizer st=new StringTokenizer(s1);
System.out.println("the string has :"+st.countTokens()+" tokens");
while (st.hasMoreTokens())
System.out.println(st.nextToken());
Wrapper classes:
The main objectives of wrapper classes are:
To Wrap primitives into object form. So that we can handle primitives also just like
objects.
To Define several utility functions for the primitives(like converting primitive to the
string form etc.
Each of java’s 8 primitive data types has classes. And those classes are called as
Wrapper classes because they wrap the data into an object.
Primitive data types Wrapper class
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character
All wrapper classes belongs to java.lang package
Constructing Wrapper objects by using constructors

Every Wrapper class contains 2 constructors one can take the corresponding
primitive as the argument and the other can take the corresponding string as the
argument.
Integer class
public class Demo {
public static void main(String args[]) {
Integer I = new Integer(10);
Integer I1 = new Integer("10");
System.out.println(I);
System.out.println(I1);
Note:If the String is unable to convert into the number form then we will get run time
exception saying “NumberFormatException“.
Float class
This class contains 2 constructors which can take double, String as argument.
Character class
This class contain only one constructor which can take char as the argument i.e
character class doesn’t contain a constructor which can take string as the
argument.
Boolean class
This class contains 2 constructors one can take boolean primitive. Other can take string argument. If you
are providing boolean primitive as the argument then. The allowed values are true or false.
Case is not important if the content contains ‘TRUE’ then it is considered as true other wise it considered as
false.
public class Demo {
Boolean b = new Boolean(true); //true
Boolean b1 = new Boolean(false);//not valid
Boolean b2 = new Boolean("false");//false
Boolean b3 = new Boolean("TrUE"); //true
Boolean b4 = new Boolean("raju"); //false
Boolean b5 = new Boolean("yes");//false
}
valueOf method:
All the wrapper classes except Character class contains the valueOf() method for
converting string to corresponding Wrapper Object.
public static wrapper valueOf(String s);
public class Demo {
Integer I = Integer.valueOf("10");//10
Float F = Float.valueOf("10.5");//10.5
Boolean B = Boolean.valueOf("java");//false
//Character ch = Character.valueOf("10");//invalid
All Integral wrapper classes “Byte, Short, Long, Integer” Contains the following
valueOf() method.
public static wrapper valueOf(String s, int radix);
The allowed base of radix is 1 to 36.Because Numerics(10) ,Alphabets(26) finally
10+26 =36
public class Demo {
Integer I = Integer.valueOf("101011", 2);

System.out.println(I);
Every Wrapper class including character class contains the following valueOf() method
to convert primitive to wrapper object form.
public static wrapper valueOf(primitive p);
public class Demo {
Integer I = Integer.valueOf(10);
Character ch = Character.valueOf('a');
Boolean B = Boolean.valueOf(true);
xxxValue() method
Every wrapper class Except character and Boolean classes contains the following
xxxValue() methods for converting wrapperObject to primitive.
public int intValue();

public byte byteValue();
public short shortValue();
public long longValue();
public float floatValue();
public int doubleValue();
public class Demo {
Integer I = Integer.valueOf(130);
System.out.println(I.byteValue());
System.out.println(I.shortValue());
System.out.println(I.intValue());
System.out.println(I.longValue());
System.out.println(I.floatValue());
System.out.println(I.doubleValue());
Character class contain charValue() method to return char primitive for the given
character wrapper object.
public char charValue();
public class Demo {
Character ch = new Character('a');
char ch1 = ch.charValue();
System.out.println(ch1);
}
Boolean class contains booleanValue() method to return boolean primitive for the given
boolean object.
public class Demo {
Boolean B = Boolean.valueOf("MNC");
boolean b1 = B.booleanValue();
System.out.println(b1);
Java.lang.Integer:
Constructor:
public Integer(int)
it is used to convert from primitive type to reference type
method:
public int intValue()
it is used to convert reference type to primitive type

ex: primitive to reference type:
int x=5;
Integer ob=new Integer(x);
Ex: reference type to primitive type:
Integer ob=new Integer(5);
int x=ob.intValue();
Autoboxing:
The process of converting primitive type variable to the corresponding reference type
variable is called autoboxing
int x=5;
Integer ob=x; // autoboxing
Auto Unboxing:
The process of converting reference type variable to the corresponding primitive type
variable is called autounboxing
Integer ob=new Integer(5);
int x=ob;
class Demo
{
int x=10;
Integer ob=new Integer(x);
Integer ob2=new Integer(7);
int y=ob2.intValue();
System.out.println(y);
Integer ob3=87;// autoboxing
System.out.println(ob3);
Integer ob4=new Integer(100);
int z=ob;//autounboxing
System.out.println(z);
Exception Handling
Error:
A programming mistake is said to be an error
Types of errors:
1.compile time errors(syntax errors)
2.run time erros(exceptions)
3.Logical errors
Exception means runtime error
Exception is an unwanted and unexpected event that disturbs normal flow of the program is
called exception.
If we are not handling exception,the program may terminate abnormally without releasing
allocated resources.This is not a graceful termination.Being a good programming
practice compulsory we should handle exceptions for graceful termination of the
program.
Exception handling doesn’t mean repairing an exception just we have to provide alternative
path to continue the program normally.
Run time Stack Mechanism
For every thread in java JVM provides a run time stack.
All the method calls performed by that thread will be sorted in the corresponding run time
stack.
Once the method terminates normally, the corresponding entry from the stack will be
removed.
After completing all method calls the stack will become empty and JVM destroys that stack
before terminating the thread.
Ex:
public class ExcpetionHandDemo {
doStuff();
public static void doStuff() {
doMoreStuff();
public static void doMoreStuff() {
System.out.println("Exception thread..");
Default Exception Handling
When ever an exception raised by the method ,then that method is responsible for the
preparation of exception object by including the following information.
Name of Exception.
Description.
Location of Exception.
After preparation of Exception Object, The method handovers that object to the JVM.
JVM will check for Exception handling code in that method, if the method doesn’t contain
any exception handling code then JVM terminates that method abnormally and
removes corresponding entry from the stack.
JVM will check for exception handling code in the caller,and if the caller method also doesn’t
contain exception handling code then JVM terminates that caller method abnormally
and removes corresponding entry from the stack.
This process will be continued until main method and if the main method also doesn’t
contain any exception handling code then JVM terminates main method abnormally.
Just before terminating the program,JVM handovers the responsibilities of exception

handling to the default exception handler.
Default exception handler prints the exception information to the console and terminates
the program abnormally.
public class ExcpetionDemo {
doStuff();
public static void doStuff() {
doMoreStuff();
public static void doMoreStuff() {
System.out.println(10/0);
/*
Output:
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo.doMoreStuff(ExceptionDemo.java:12)
at ExceptionDemo.doStuff(ExceptionDemo.java:8)
at ExceptionDemo.main(ExceptionDemo.java:5)
*/
Exception Hierarchy
The Java exception hierarchy starts from Throwable class i.e for all java Exceptions and
Errors Throwable is parent class
Throwable has 2 child classes
Exception:Most of the times, Exceptions are caused by due to our program code only and
these are recoverable
Error:Most of the times errors are raised due to lack of system resources and Errors are
non-recoverable.
Checked Exceptions Vs UnChecked Exceptions

checked exceptions.
The Exceptions which are checked by the compiler for smooth execution of the program at run
time are called checked exceptions.
Example: FileNotFoundException, InterruptedException.
The exception classes which are derived from java.lang.Exception class are called
checked exceptions
They do not include java.lang.RuntimeException class and all its subclasses
All checked exceptions must be handled by the programmer explicitely by using try catch
block or throws key word other wise compile time error will occurs
The compiler checks for try and catch block or throws keyword for this kind of
exceptions.
All apption specific exceptions are comes under this category
java.io.FileInputStream:
constructor:
public FileInputStream(String) throws FileNotFoundException;
it opens a file for reading if the file is exist , otherwise FileNotFoundException is thrown.
FileNotFoundException is a checked exception and it must be handled by programmer

explicitely by using try catch block.
import java.io.FileInputStream;
public class Demo
FileInputStream fis=new FileInputStream(args[0]);
2.Unchecked exceptions:
The Exceptions which are unable to checked by the compiler are called ‘unchecked
exceptions’
Runtimeexception and it’s child classes, Error and it’s child classes are considered as
unchecked
exceptions and all the remaining considered as checked.
The exception classes which are derived from java.lang.RuntimeException class are called
Unchecked exceptions
All unchecked exceptions are handled by JVM implicitely
Handling unchecked exceptions by a programmer is optional
The java compiler does not check for try catch or thorows keyword for this kind of
exceptions.
All general exceptions are comes under this category
java.lang.Integer:
Method()
public static int parseInt(String) throws NumberFormatException
Number format exception is a unchecked exception and it is handled by system implicitely
Ex: public class Demo
int x=Integer.parseInt(args[0]);
}
}
The above program successfully compiles
Partially checked Vs fully checked

A checked exception is said to be fully checked iff all it’s child classes also checked.
Example: IOException.
A checked exception is said to be partially checked if some of it’s child classes are not checked.
Example:Exception.
Exception Handling By Using try ,catch

We can handle the exceptions by using try catch.
We have to place the risky code inside the try block and the corresponding
exception handling code inside catch block.
try{
//Risky code
}catch (X e){
//handling code
Without Exception handling code

public class ExceptionDemo {
System.out.println("Statement1");
System.out.println(10 / 0);
}
/*
Output:
Statement1
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo.main(ExceptionDemo.java:6)
*/
Note:The above program terminates abnormally.
With Exception handling code

try {
} catch (ArithmeticException exception) {
System.out.println("Exception block:" + (10 / 2));
/*
Statement1
Exception block:5
Statement2
*/
Note:The above program terminates normally.
All exceptions are classes in java
In exception handling we use following keywords
try, catch, throw ,throws and finally
When ever exception occurs in java a related exception class object is created by jvm and it
will be thrown to a catch block
The catch block is called as an exception handler and it handles the exception object.
public class Test
{
int y=Integer.parseInt(args[1]);
int z=x/y;
In the above example all the exceptions are handled implicitely
In the above example throwable class toString() is called
The above example a programmer can also handle the exceptions explicitely to change the
default messages of the exceptions
Syntax of try catch block:
Try
----
Catch(Exceptionclassname objectreference)
--
-- user friendly messages/error messages
Try block must be associated with atleast one catch block or finally block
public class Test
{
try
int z=x/y;
catch(ArrayIndexOutOfBoundsException ae)
System.out.println("please pass two arguments:");
catch(NumberFormatException nfe)
System.out.println("please pass integers only:");
catch(ArithmeticException ae)
System.out.println("second argument is a non zero element");
}
}
public class Test
try
int z=x/y;
catch(RuntimeException ae)
System.out.println("please pass two integers and second argument

except zero:");
}
Note: in the above example catch block handles RuntimeException class object and all its
sub classes
Control Flow in try, catch

try
statement 1;
statement 2;
statement 3;
catch (X e)
statement 4;
statement 5;
Case1: if there is no exception
1,2,3,5 normal termination.
Case2: if there is an exception raised at statement 2 and the corresponding catch block
matched.
1,4,5 normal termination.
Case3: if an exception raised at statement 2 but the corresponding catch block is not
matched
1 Abnormal termination.
Case4: if an exception raised at statement 4 or statement 5 it is always abnormal

termination.
try with multiple catch blocks

The way of handling exception is varies from exception to exception. Hence for every
exception we should define corresponding catch blocks hence try with multiple catch
blocks is possible.
try
risky code
catch (ArithmeticException e )
//handler to A.E
catch (NullPointerException e)
//handler for N.P.E
catch(IOException e)
//handler for IOException
catch(Exception e)
//handler for Exception

}
In the case of try with multiple catch blocks the order of catch blocks is important. And it
should be from
child to parent other wise Compiler Error. Saying Exception xxx has already been caught
Example:Parent to Child
try{
}catch (Exception ex) {
ex.printStackTrace();
}catch (ArithmeticException e){
e.printStackTrace();
Example:Child to Parent

try {
} catch(ArithmeticException e) {
System.out.println("ArithmeticException block");
} catch(Exception ex) {
System.out.println("Exception block");
If there is no chance of raising an exception in try block then we can’t keep

corresponding catch block otherwise we will get compile time error saying
“exception is never thrown in the body of corresponding try statement“.But this rule is
appble only for fully checked exceptions.
import java.io.IOException;
try{
System.out.println("Hello");
}catch (IOException ex) {
ex.printStackTrace();
}
Note:IOException is fully checked exception.
try {
System.out.println("hello");
} catch(Exception e) {
System.out.println("Exception block");
Finally
It is not recommended to place cleanup code inside try statement because there is no
guarantee for
execution of all statements inside try block.
It is not recommended to maintain cleanup code with in the catch block because if there is
no exception the catch blocks won’t be executed.
We required a block to maintain cleanup code which should execute always irrespective of
whether the
exception is raised or not whether it is handled or not , such block is nothing but “finally
block”
Hence the main objective of finally block is to maintain cleanup code.

try
//open the database connection
//read the data
catch (X e)
finally
close the Connection
Ex:
try
System.out.println("try");
catch (ArithmeticException e)
System.out.println("catch");
finally
{
System.out.println("finally");
O/P: try
finally
Normal Termination
Ex:
try
catch (ArithmeticException e)
finally
O/P: catch
Finally
Normal Termination
Ex:
try
catch (NullPointerException e)
finally
O/P: finally
Abnormal termination
Hence finally block should always execute irrespective of whether the exception is raised or
not raised or
handled or not handled

Difference Between final, finally, finalize
final: It is the modifier appble for classes methods and variables. For final classes we can’t
create
child classes i.e inheritance is not possible.
final methods can’t be override in child classes for final variables reassignments is not
possible
because they are constants.
finally: It is a block associated with try catch the main objective of finally block is to
maintain
cleanup code which should execute always.
finalize: It is a method should be executed by the “Garbage Collector” just before destroying
an
object. The main objective of finalize method is to maintain cleanup code.
Possible combinations of try, catch, finally

Customized Exception
Based on our programming requirement some times we have to create our own exception,
which are nothing but “Customized Exception”.
program to create and handle checked exception

class NegetiveNumberException extends Exception
public class Demo
void cube(int a)throws NegetiveNumberException
if(a>0)
System.out.println(a*a*a);
else
throw new NegetiveNumberException();
public static void main(String[] args) throws Exception
try
Demo ob=new Demo();
ob.cube(x);
}
catch(NegetiveNumberException e)
System.out.println(e);
program to create and handle unchecked exception
class NegetiveNumberException extends RuntimeException
public class Demo
void cube(int a)throws NegetiveNumberException
if(a>0)
System.out.println(a*a*a);
else
throw new NegetiveNumberException();
public static void main(String[] args) throws Exception
Demo ob=new Demo();
ob.cube(x);
throw keyword
By using throw we can hand – over exception object to the JVM.
The output of the following two programs is same.
case:1

throw new Test();
class Test{
Compiletime Error:No exception of type Test can be thrown; an exception type must be a
subclass of Throwable
case:2
throw new Test();
class Test extends RuntimeException{
Case:3
static ArithmeticException e = new ArithmeticException("/by zero");
throw e;
Here Explicitly we created a object to the ArithmeticException class and that object was
thrown by thow to the JVM.
Case 4:
static ArithmeticException e ;
throw e;
Output:
Exception in thread “main” java.lang.NullPointerException
Here we didn’t create Object to the AritmeticException class just we created a reference,
so reference variable is not pointing to any object and we thrown only reference
variable that’s why only it shows NullPointerException.
After throw statement we are not allowed to write any statement directly other wise we will
get compile time error saying that un-reachable statement
Throws keyword:
In our program,If there is any chance of raising checked exception then compulsory we
should handle that checked exception either by using try, catch or we have to
delegate that responsibility to the caller using throws keyword other wise C.E
ex:
class Demo
Thread.sleep(1000);
We can resolve this problem either by using try catch or by using throws keyword as follows
class Demo
try
Thread.sleep(1000);
catch (InterruptedException e)
System.out.println(e);
}
class Demo
public static void main(String arg[])throws InterruptedException
Thread.sleep(1000);
Hence the main objective of throws keyword is to delegate the responsibilities of exception
handling to the
Caller method incase of checked exceptions
In the case of unchecked exceptions it is not required to use the throws keyword
The Methods to display Exception Information

Throwable class contains the following methods to display error information.
printStackTrace: It displays error information in the following format.

Name of Exception : Description
StackTace.
toString: it displays error in the following format.

Name of Exception : Description
getMessage: it displays error information in the following format.

Description
Ex:-
Note: by default printStackTrace method is used by default exception handler

Note: Default Exception handler always uses printStackTrace method only.
Multithreading
Multitasking Executing several tasks simultaneously is called ‘Multitasking’,
There are 2
types of multitasking.
1) Process based Multitasking.
2) Thread based Multitasking.
Process based Multi Tasking
Executing several tasks simultaneously where each task is a separate independent

process is
called ‘Process based Multitasking’.
Ex:
While writing java program in the editor we can run MP3 player. At the same time
we
can download a file from the net. All these tasks are executing simultaneously and
independent of each other. Hence it is process based Multitasking. Process based
Multitasking is best suitable at O.S level.
Thread based Multitasking.
Executing several tasks simultaneously where each task is a separate independent

part of the
same program is called Thread based Multitasking. This type of multitasking is best
suitable
at programmatic level.
Java provides in built support for thread based multitasking by providing rich
library (Thread,
ThreadGroup, Runnable ..etc)
Whether it is Processbased or Threadbased the main objective of multitasking is to

reduce
response time and improve performance of the system.
The main apption area of multithreading is videogames implementation,

,Multimedia graphics
…etc.
Defining ,Instantiating, Starting the Thread

We can define instantiate and starting a thread by using the following 2- ways.
1) By extending Thread Class.
2) By implementing Runnable interface.
By extending Thread Class

Ex:
class MyThread extends Thread
{
public void run()
for (int i=0; i<10; i++ )
System.out.println("Child Thread");
class MultiThreadDemo
MyThread t = new MyThread();
t.start();
for(int i = 0; i<10; i++)
System.out.println("Main Thread");
Case1 :
Thread Shedular:
If multiple threads are there then which thread will get chance first for execution
will be
decided by “Thread Scheduler”. Thread Scheduler is the part of JVM. The behavior
of thread
scheduler is vendor dependent and hence we can’t expect exact O/P for the above
program.
The possible Outputs are:
Note: when ever the situation comes to multithreading the guarantee in behavior is
very less we can tell possible output but not exact output
Case2:
The difference between t.start() & t.run():
In the case of t.start() a new thread will be created and which is responsible for the
execution
of run( ) method. But in the case of t.run() no new thread will be created and run()
method will be executed just like a normal method by the main thread.
Hence in the above program if we are replacing t.start() with t.run() then the O/P is
Case3:
Importance of Thread Class start() method:
After Creating thread object compulsory we should perform registration with the
thread
scheduler. This will take care by start( ) of Thread class, So that the programmers
has to
concentrate on only job. With out executing Thread class start() method there is no
chance of
start a new Thread in java.
start()
Register our thread with the thread scheduler.
Invoke run method.
Case4:
If we are not overriding run() method:
Then the thread class run method will be executed which has empty
implementation.
Ex:
class ThreadDemo
{
t.start();
O/P:- no output
Note: it is highly recommended to override run method to define the job of a thread
Note:overloading of run( ) method is possible but thread class start( ) method

always call no argument run only. But the other run methods has to call just
like normal method call.
Case5:
If we are overriding start() method:
Ex:
public void start()
System.out.println("start() method");
public void run()
System.out.println("run method");
class ThreadDemo
{
t.start();
O/P:- start() method
In this case start() method will be executed just like a normal method.
Life cycle of Thread

When u write new MyThread()
Once we crated a thread object then it is said to be in new state or born state
If we call start( ) method then the thread will be entered into ready or runnable
state
If threadshedular allocates cpu then the thread will entered into running state
If run( ) method completes its execution then the thread will entered into deadstate
Note:- we can’t stop a running Thread explicitly. But until 1.2 version we can
achieve this by using
stop() method but it is deprecated method. Similarly suspend() and resume()

methods also
deprecated.
After starting a thread we are not allowed to restart the same thread once again,
violation leads to Runtime Error saying “IllegalThreadStateException”.
t.start();
-----
-----
t.start(); // Illegal Thread state Exception.
Within the run method if we call super.start( ) method we get the same runtime
error “IllegalThreadStateException”.
It is never recommended to override start( ) method. But it is recommended to

override run( ) method
Defining a thread By Implementing Runnable Interface

We can define a Thread by implementing runnable interface also. Runnable
interface available in java.lang package and contains only one method
public void run();

Ex:
class MyRunnable implements Runnable
public void run()
for(int i = 0;i<=10;i++)
class ThreadDemo
MyRunnable r = new MyRunnable();
Thread t = new Thread(r);
t.start();
for(int i = 0;i<=10;i++)
Ex:
MyRunnable r = new MyRunnable();

Thread t1 = new Thread();
Thread t2 = new Thread(r);
Case1:
t1.start();
A new thread will be started and executes Thread class run( ) method(Which is
having empty
implementation).
Case2:
t1.run();
No new thread will be created and Thread class run() method will be executed just
like a
normal method call.
Case3:
t2.start();
A new thread will be created and responsible for execution of MyRunnable run( )
method.
Case4:
t2.run();
No new thread will be created and MyRunnable run( ) method will be executed just
like a
normal method call.
Case5:
r.run();
No new thread will be created and MyRunnable run( ) method will be executed just
like a
normal method call.
Case6:
r.start();
Compiler Error: MyRunnable doesn’t contain start method.
Note:- Among 2- approaches of defining a thread – implements Runnable is always

recommended to
use in the 1st approach as we are already extending thread class. There is no chance
of extending any other class. Hence we are missing the key benefits of oops
inheritance(reusability) . hence this approach is not recommended to use.
setting and getting the name of a Thread
every thread in java has some name it may be provided by programmer or a default
name generated by jvm
Thread class defines the following methods to set and get the name of a Thread.
1) public final void setName(String name);
2) public final String getName();
Ex:
class Test
System.out.println(Thread.currentThread().getName());
Thread.currentThread().setName("New Thread");
System.out.println(Thread.currentThread().getName());
Note: we can get current executing thread reference by using the following method
of thread class
public static Thread currentThread( );
Thread Priorities:
Every Thread in java having some priority. The range of valid thread priorities is
(1-10) (1 is least & 10 is Highest). Thread class defines the following
constant for representing some standard priorities.
Thread.MIN_PRIORITY 1
Thread.NORM_PRIORITY 5
Thread.MAX_PRIORITY 10
Thread scheduler use these priorities while allocating C.P.U. The Thread which is
having highest priority
will get chance first for execution. If two threads having the same priority then
which thread will get chance first for execution is decided by Thread
Scheduler, which is vendor dependent i.e we can’t expect exactly.
The default priority for the main thread only the 5, but for all the remaining threads
the priority will be inherit from parent i.e what ever the parent has the same
priority the child thread also will get.
Thread class contains the following methods to set and get priorities of thread.
public final void setPriority(int priority)
public final int getPriority();
where priority should be from 1-10 other wise R.E: IllegalArgumentException.
Ex:
public void run()
for (int i=0; i< 10 ; i++ )
class ThreadPriorityDemo
{
System.out.println(t.getPriority());
t.setPriority(10);//------------'(1)
t.start();
System.out.println("thread name is:"+Thread.currentThread().getName()+ "

priority is: "+t.getPriority());
for(int i =0;i<10;i++)
If we are commenting line 1 then both main and child threads having the same
priority(5) and hence we cant expect exact execution order and exact output
If we are not commenting line 1 then main has the priority 5 and child thread have
the priority(10) and hence child thread will be executed first and then main
thread. In this case the output is child thread 10 times and mainthread 10
times will be executed
Note: Some Operating Systems may not provide support for thread priorities.
The methods to prevent thread execution
We can prevent a thread from execution by using the following methods.
1) yield()
2) join()
3) sleep()
yield()
The thread which is called yield() method temporarily pause the execution to give
the chance for remaining threads of same priority.
If there is no waiting thread or all waiting threads having low priority.
Then the same thread will get the chance immediately for the execution.
public static native void yield();
the thread which is yielded, when it will get chance once again for execution is
decided by ThreadSchedular and we can’t expect exactly.
Ex:
public void run()
for (int i=0; i< 10 ; i++ )
Thread.yield();//-----------------------(1)
}
}
class YieldDemo
t.start();
If we are commenting line 1 then both threads will be executed simultaneously and
we cant expect exact execution order
If we are not commenting line 1 then the chance of completing main thread first is
high because child thread always calls yield() method.
. As the yield method is native method some Operating system may not provide the
support for this.
join()
If a thread wants to wait until some other thread completion then we should go for
join method.
Ex:
If a thread t1 executes t2.join(), then t1 will be entered into waiting state until t2
completion.
public final void join() throws InterruptedException
public final void join(long ms) throws InterruptedException
public final void join(long ms, int ns) throws InterruptedException

Join() method is overloaded and every join() throws InterruptedException hence
when ever we are using join() compulsory we should handle
InterruptedException either by using try-catch block or by throws key word
otherwise we will get compile time error.
Ex:
public void run()
for (int i=0; i< 10 ; i++ )
try
Thread.sleep(2000);
catch(InterruptedException e)
e.printStackTrace();
class ThreadJoinDemo
{
t.start();
t.join();//--------------------(1)
If we are commenting line 1 then both threads will be executed simultaneously and
we cant expect exact execution order and hence we cant expect exact o/p.
If we are not commenting line 1 then main thread will wait until completing child
thread hence in this case the o/p is expected.
Sleep ( ):
If a thread has to wait some predefined amount of time with out execution then we
should go for sleep() method.
If a thread don’t want to perform any operation for a particular amount of time
(just pausing) then we should go for sleep()
public static void sleep(long ms)throws InterruptedException
public static void sleep(long ms, int ns)throws InterruptedException

When ever we are using sleep() compulsory we should handle interrupted
exception other wise we will get compile time error
Ex:
class Test
System.out.println("systems");
Thread.sleep(5000);
System.out.println("domain");
Thread.sleep(5000);
System.out.println("banashankari");
interrupting a thread
If any thread is in sleeping or waiting state (i.e. sleep() or wait() is invoked), calling
the interrupt() method on the thread, breaks out the sleeping or waiting
state throwing InterruptedException. If the thread is not in the sleeping or
waiting state, calling the interrupt() method performs normal behaviour and
doesn't interrupt the thread.
we can interrupt a sleeping or waiting thread by using interrupt( ) method of

thread class.
public void interrupt()
when ever we are calling interrupt() the target thread may not be effected
immediately. At the time of calling interrupt if the target thread is not in
sleeping or in waiting state interrupt call will wait until target thread
entered into sleeping or waiting state the interrupt call will impact the target
thread..
Ex:
public void run()
try
for(int i=0;i<100;i++)
System.out.println("lazy thread");
Thread.sleep(5000);
catch(InterruptedException e)
System.out.println(" i got interrupted");
class InterruptDemo
MyThread t=new MyThread();
t.start();
t.interrupt();//------------(1)
System.out.println("end of main method");
If we are commenting line 1 then main thread wont interrupt child thread hence
both threads will be executed until completion.
If we are not commenting line 1 then main thread interrupts the child thread rises
InterruptedException.
In this case the o/p is :
Synchronization
‘synchronized’ is the keyword appble for the methods and blocks. We can’t apply
this keyword for variables and classes.
If a method declared as synchronized at a time only one thread is allowed to

execute that method on the given object. The main advantage of
synchronized keyword is we can overcome data inconsistency problem. The
main limitation of synchronized keyword is it increases the waiting time of a
thread, and effects the performance of the system.
Hence if there is no specific requirement it’s not recommended to use synchronized

keyword.
Every object in java has a unique lock.
Synchronization concept internally implemented by using this lock concept.

Whenever we are using synchronized keyword then object level lock concept
will come into picture.
If a thread want to execute any synchronized method on the object first it should
require the lock of that object. Once a thread got the lock then it is allowed to
execute any synchronized method on that object.
Once synchronized method completes then automatically the lock will be released
While a thread executing a synchronized method on the object, then the remaining
threads are not allowed to execute any synchronized method on the same
object. But the remaining threads are allowed to execute any non-
synchronized method on the same object.
Every object in java has unique lock but a thread can acquire more than one lock at
a time.
Ex:
class Display
public synchronized void wish(String name)
System.out.print("Hai.......!");
try
Thread.sleep(2000);
System.out.println(name);
Display d;
String name;
MyThread(Display d,String name)
this.d = d;
this.name = name;
public void run()

{
d.wish(name);
class SynchronizedDemo
Display d = new Display();
MyThread t1 = new MyThread(d," Dhoni ");
MyThread t2 = new MyThread(d," Yuvraj ");
t1.start();
t2.start();
If we are not declaring wish method as “synchronized” we will get irregular o/p
because both threads will execute simultaneously. If we are declaring wish
method as synchronized we will get regular o/p because at a time only one
thread is allowed to execute wish method.
Display d1 = new Display();
Display d2 = new Display();
MyThread t1 = new MyThread(d1,"Dhoni");
MyThread t2 = new MyThread(d2,"Yuvraj");
t1.start();
t2.start();
Even though wish method is synchronized we will get irregular o/p only because
both threads are operating on different objects.
Class level lock: If a thread want to execute any static synchronized method then
compulsory that thread should require class level lock.
While a thread executing any static synchronised method then the remaining
threads are not allowed to execute any static synchronized method of the
same class simultaneously.
But the remaining threads are allowed to execute any non-synchronized static
methods, synchronized – instance method, non – synchronized instance
method simultaneously.
Declare static synchronized in display method and try the above example we will
get regular o/p because there is class level lock.
Synchronized Blocks
It is not recommended to declare entire method as synchronized if very few lines of
code requires the synchronization concept. Such a few lines of code we can
declare in a block rather than declaring entire method as a synchronized
method
Syntax:
synchronized(b)
//critical section.
Where ‘b’ is an object reference.
To get the lock for the current object we can define synchronized block as follows
synchronized(this)
//critical section.
We can define synchronized block to get class level as follows
synchronized(Display.class)
we can define synchronized block either for object references or for class
references But not for primitives violation leads to Compile time error.
int i =10;
synchronized(i)
//------
C.E:- unexpected type
found : int.
required : reference.
Synchronized statement(Only for Interview Purpose):
The statement which are defined in inside synchronized method or synchronized

blocks are called
‘synchronized statement’.
Inter Thread Communication

Two threads can communicate with each other by using wait(), notify(), notifyAll().
These methods are available in object class but not in thread class. Because threads
are calling these methods on any object.
We should call these methods only from synchronized area other wise we get
runtime exception saying
IllegalMonitorStateException.
If a thread executes wait() method it immediately releases the lock of that

object(But not all locks) and entered into waiting state.
After giving the notification also the thread releases the lock but may not be
immediately.
public final void wait() throws InterruptedException
public final void wait(long ms) throws InterruptedException
public final void wait(long ms, int ns) throws InterruptedException
public final void notify();
public final void notifyAll();

sleep(): It is a static method on Thread class. It makes the current thread into the
"Not Runnable" state for specified amount of time. During this time, the
thread keeps the lock (monitors) it has acquired.
wait(): It is a method on Object class. It makes the current thread into the "Not
Runnable" state. Wait is called on a object, not a thread. Before calling wait()
method, the object should be synchronized, means the object should be
inside synchronized block. The call to wait() releases the acquired lock.
Ex:
class ThreadA
ThreadB b = new ThreadB();
b.start();
synchronized(b)
System.out.println("Main thread is trying to call wait()");
b.wait();
System.out.println("Main thread got notification");
System.out.println(b.total);
}
class ThreadB extends Thread
int total = 0;
public void run()
synchronized(this)
System.out.println("Child thread starts calculation");
for(int i = 1; i<=100; i++)
total = total + i;
System.out.println("child thread trying to give notification ");
this.notify();
Dead Lock
If two threads are waiting for each other forever, then the threads are said to be in
“deadlock”.
There is no deadlock resolution technique but prevention technique are available
Ex:
Banker’s Algorithm.
Ex:
class A
synchronized void foo(B b)
System.out.println("Thread 1 entered foo() method");

try
Thread.sleep(600);
System.out.println("Thread 1 is trying to call b.last()");
b.last();
synchronized void last()
System.out.println("Inside A, This is last() method");
class B
synchronized void bar(A a)
System.out.println("Threas 2 entered bar() method");
try
Thread.sleep(600);
System.out.println("Thread 2 is trying to call a.last()");

a.last();
synchronized void last()
System.out.println("Inside B, This is last() method");
class DeadLock implements Runnable
A a = new A();
B b = new B();
DeadLock()
Thread t = new Thread(this);
t.start();
b.bar(a);
public void run()
a.foo(b);
new DeadLock();
DaemonThread
The threads which hare running in the background to provide support for user
defined threads are called
“Daemon Thread”. Usually daemon thread are running with low priority but based
on our requirement we
can increase their priority also.
We can check whether the given thread is daemon or not by using the following
thread class thread.
public boolean isDaemon()
we can change the daemon nature of a thread by using setDaemon() method of

thread class.
public void setDaemon(Boolean b)
the daemon nature of a thread is inheriting from the parent. i.e if the parent is
daemon then the child is also
daemon and if the parent is non – daemon then the child is also non – daemon.
After starting a thread we are not allowed to change the daemon nature violation
leads to runtime exception
saying IllegalThreadStateException.
Ex:
class Test
System.out.println(Thread.currentThread().isDaemon());
System.out.println(t.isDaemon());
t.setDaemon(true);
System.out.println(t.isDaemon());
t.start();
//t.setDaemon(false); - 1
}
If we don’t comment line 1 we will get the IlleagalThreadStateException, see the

following o/p.
We can’t change the daemon nature of main thread because it has started already
before main() method only.
All the daemon threads will be terminated automatically when ever last non –
daemon thread terminates.
Ex:
If we are commenting line 1, then both child and main threads are non – Daemon,
hence they will execute until their completion.
If we are not commenting line 1, then the child thread is daemon and hence it will
terminate automatically
when ever main() thread terminates.
COLLECTIONS FRAME WORK
Limitations of Object Arrays

An array is an indexed collection of fixed number of homogeneous data elements.
The main limitations of Object Arrays are
1) Arrays are fixed in size i.e once we created an array there is no chance of
increasing or
decreasing it’s size based on our requirement.
2) Arrays can hold only homogeneous data elements.
Ex:-
Student [] s = new Student [600];

s[0] = new Student;
s[1] = new Integer(10); X
s[2] = "raju"; X
We can resolve this problem by using object Arrays.
Object [] o = new Object [600];
o[0] = new Student;
o[1] = new Integer(10);
o[2] = "raju";
i.e By using Object Arrays we can hold heterogeneous data elements.
3) For the Arrays there is no underlying Data Structure i.e for every requirement
we have to code explicitly and there is no default ready made support(like
sorting, searching).
we can’t represent array elements in some sorting order by default. We can’t

prevent duplicate
object insertion etc…
To resolve the above problems of arrays, Sun people has introduced ‘collections
concept’
Collections are grow able in nature i.e based on requirement we can increase or
decrease the size.
Collections can hold heterogeneous data elements also.
Every collection class has implemented based on some data structure
Hence for every requirement ready made method support is possible.
We can represent all the elements in some sorting order. We can prevent duplicate
object insertion by default.
Comparison Between collections and Arrays

Collections Arrays
1) Collections are not fixed In size. 1) Arrays are fixed In size.
2) With respect to memory collections 2) with respect to memory arrays are

are good. not good.
3) With respect to performance 3) With respect to performance the

collections shows worst arrays are
performance.
recommended to use.
4) Collections can hold heterogeneous 4) Arrays can only hold homogeneous

data data
elements elements.
5) Every Collection class has built by 5) There is no underlying Data

using some Data structure. Structure.
6) Collection can hold only Objects but 6) Arrays can hold both Objects and
not primitives.
primitives.
Collections Frame Work

It defines group of classes and interfaces which can be used for representing a
collection of Objects as single entity.
7 key Interfaces of collection Frame Work

1) Collection :
This interface is the root interface for entire collection framework.
This interface can be used for representing a group of objects as single entity.
This interface defines the most common general methods which can be appble for
any collection object. There is no concrete class which implements collection
interface directly.
Difference Between Collection and Collections
Collection is an interface available in java.util package for representing a group of

objects as single entity.
Collections is an utility class available in java.util package and defines several

utility methods for collection implemented class object
2) List interface :
This can be used for representing a group of individual objects as a single entity
where insertion order is preserved and duplicate objects allowed. This is
child interface of collection.
The following classes implemented List interface directly.
ArrayList, LinkedList, Vector and Stack.

3) Set interface :
This can be used for representing a group of individual objects where
duplicate objects are not allowed and insertion operation is not preserved.
This is the child interface of collection
hashset and linkedHashSet are the classes which implements Set interface directly.
4) SortedSet interface :
This can be used for representing a group of individual and unique objects.
Where all the objects are inserted in some sorting order. It is the child interface of
Set interface
TreeSet is the implemented class of SortedSet

5) Queue interface:
The java.util.Queue interface is a subtype of

the java.util.Collectioninterface. It represents an
ordered list of objects just like a List , but its
intended use is slightly different. A queue is
designed to have elements inserted at the end of
the queue, and elements removed from the
beginning of the queue.
All the above interfaces(collection, List, Set, SortedSet, Queue) can be used for
representing a group of individual objects.
If u want to represent a group of objects as key value pair than we can’t use above
interfaces.
To handle this requirement sun people has introduced map interface.
6) Map:
This can be used for representing a group of objects as key value pairs. Both key
and value are
objects only.
StudentName StudentRollNo
phoneNumber contactdetails
word meaning
IP Address Domain-name
Note: Map interface is not child interface of collection.
7) SortedMap:
This can be used for representing a group of objects as key value pairs where all the
entries are
arranged in some sorting order of keys.
TreeMap is the class which implements SortedMap interface.
The following are legacy classes in collection Frame Work.
1) vector.
2) stack
3) Hashtable concrete classes
4) properties
5) Dictionary----- abstract classes

6) Enumaration--- interface
Collection
This can be used for representing a group of individual objects as a single entity.
This interface defines the most common general methods. Which can be
appble for any collection implemented class object.
Colletion Interface methods
1)boolean add(Object obj)
2) boolean addAll(Collection c)
3) boolean remove(Object obj)
4) boolean removeAll(Collection c)
(Removes particular group of objects.)
5) boolean retainAll(Collection c)
(Removes all the elements except those present in ‘c’)
6) void clear()
(Removies all objects.)
7) boolean contains(Object obj)
(Checks object is there or not.)
8) boolean contains (Collection c)
9) boolean isEmpty()
10) int size()
11) Object [] toArray()
12) Iterator iterator()
(to retrieve the objects one by one.)
List interface
This can be used for representing a group of individual objects where insertion
order is preserved and duplicate objects are allowed.
By means of index we can preserve insertion order and we can differentiate
duplicate objects.
List Interface Defines the following methods
1) boolean add(Object obj)
2) boolean add(int index, Object obj)
3) boolean addAll(Collection c)
4) boolean addAll(int index, Collection c)
5) boolean remove(Object obj)
6) Object remove(int index)
7) Object set(int index, Object new)
Old object. It replaces with the existing objected located at specified index with the
new
object. And it returns object.
8) Object get(int index)
9) int indexOf(Object obj)
10) int lastIndexOf(Object obj)
11) ListIterator listIterator()
ArrayList()
The underlying data Structure for ArrayList() is resizable Array or “Growable
Array”.
Duplicate objects are allowed.
Insertion order is preserved.
Heterogeneous objects are allowed.
‘null’ insertion is possible.
Constructors of Array List
ArrayList l = new ArrayList()
Creates an empty ArrayList object with default intitial capacity 10.
When ever ArrayList reaches its max capacity a new ArrayList Object will be
created with new
capacity.
ArrayList l = new ArrayList(int initial capacity)
Creates an empty ArrayList Object with the specified initial capacity.
ArrayList l = new ArrayList(Collection c)
For inter conversion between collection objects.
Ex:
import java.util.*;
class ArrayListDemo
ArrayList a = new ArrayList();
a.add("A");
a.add(new Integer(10));
a.add("A");
a.add(null);
System.out.println(a);
a.remove(2);
a.add(2,"M");
a.add("N");
ArrayList and vector classes implement RandomAccess interface. So that we can

access any element with the same speed. Hence ArrayList is best suitable if
our frequent operation is retrieval operation.
Usually the collection objects can be used for data transport purpose and hence
every collection
implemented class already implemented serializable and cloneable interfaces.
ArrayList is the worst choice if u want to perform insertion or deletion in the

middle.
Note:- ArrayList is not recommended if the frequent operation is insertion or

deletion in the middle.
To handle this requirement we should go for linked list.
LinkedList()
The underlying Data Structure for linked list is doubly linked list.Duplicate objects
are allowed.

Implements List, Queue, serializable, clonealbe Interfaces But not RandomAccess.
LinkedList is the bestchoice if our frequent operation is insertion or deletion in the

middle(no shift operations are required)
LinkedList is the worst choice if our frequent operation is retrieval operation.
LinkedList class usually used for implementing stacks and Queues to provide
support for this
requirement, LinkedList class contains the following specific methods.
1. void addFirst(Object obj)
2. void addLast(Object obj)
3. Object removeFirst()
4. Object removeLast()
5. Object getFirst()
6. Object getLast()
Constructors
LinkedList l = new LinkedList()
LinkedList l = new LinkedList(Collection c)
For inter conversion between collection objects
Ex:
import java.util.*;
class LinkedListDemo
x --------------------------------
insertion
shifting
LinkedList l = newLinkedList();
l.add("raju");
l.add(new Integer(10));
l.add(null);
l.add("raju");
l.set(0, "chinna");
l.add(0, "Kiran");
l.addFirst("AAAA");
l.addLast("ZZZZ");
System.out.println(l);
Inter conversion between collection objects.
ArrayList l1 = new ArrayList();
l1.add(10);
l1.add(20);
l1.add(30);
System.out.println("l1--->"+l1);
LinkedList l2 = new LinkedList(l1);
l2.add(1,5);
l2.add(3,5);
l2.add(5,15);
ArrayList l3 = new ArrayList(l2)
VectorClass
The underlying Data structure for the vector is resizable array or growable array.
Duplicate objects are allowed.
Best choice if the frequent operation is retrieval.
Worst choice if the frequent operation is insertion or deletion in the middle.
Vector class implemented serializable, cloneable and RandomAccess Interfaces.
Difference between vector and ArrayList?
Vector ArrayList
1) All methods of vector are 1) no method is synchronized

synchronized
2) vector object is thread safe 2) ArrayList object is not thread safe by

default
3) performance is low 3) performance is High
4) 1.0 version(Legacy) 4) 1.2 version(non Legacy)
We can get synchronized version of ArrayList of by using the following method of

collections class.
ArrayList l1 = new ArrayList();

List l2 = Collections.synchronizedList(l1);
Synchronized non-synchronized
Similarly we can find synchronized versions of set and Map objects by using the
collections class
method.
public static Set synchronizedSet(Set s1)
public static Map synchronizedMap(Map m1)
Vector methods
For adding objects.
add(Object obj)
add(int index, Object obj)
addElement(Object obj)
For removing Objects
remove(Object obj)
removeElement(Object obj)
remove(int index)
removeElementAt(int index)
clear()
removeAllElements()
For Accessing Elements
Object get(int index)
Object elementAt(int index)
Object firstElement();
Object lastElement();
OtherMethods
int size();
int capacity();
Enumaration elements();
constructors
Vector v = new Vector();
Creates an empty vector object with default initial capacity 10, when ever vector
reaches it’s max capacity a new vector object will be created with.
Vector v = new Vector(int initialCapacity)
Vector v = new Vector(int initialCapacity, int incrementalCapacity)
Vector v = new Vector(Collection c)
Ex:
import java.util.*;
class VectorDemo
System.out.println(v.capacity());
for (int i = 0;i<10 ;i++ )
v.addElement(i);
v.addElement("Aa");
System.out.println(v);
Stack
It is the child class of Vector contains only one constructor.
Stack s = new Stack();

Methods
Object push(Object obj);
For inserting an object to the stack
Object pop();
It removes and returns top of the stack.
Object peek();
Returns the top of the stack with out removal of object.
int search(Object obj);
If the specified object is available it returns its offset from top of the stack
If the object is not available then it returns -1.
boolean empty();
returns true if the stack is empty otherwise false.
Ex:
import java.util.*;
class StackDemo
Stack s = new Stack();
s.push("A");
s.push("B");
s.push("C");
System.out.println(s.search("A"));
System.out.println(s.search("Z"));
Cursors Available in collection frame work

To visit objects one by one from Collection we have to use cursors.
From the collection object to retrieve objects we can use the following 3 cursors.
1. Enumeration
2. Iterator
3. ListIterator
Enumeration
This interface has introduced in 1.0 version it contains the following 2 methods.
boolean hasMoreElements();
Object nextElement();
Ex:
import java.util.*;
class EnumaretionDemo
for (int i =0;i<=10 ;i++ )
v.addElement(i);
Enumeration e = v.elements();
while (e.hasMoreElements())
Integer i = (Integer)e.nextElement();
if((i%2) == 0)
System.out.println(i);
}
Limitations of Enumeration
1. It is appble only for legacy classes and it is not a universal cursor.
2. While iterating the elements by using enumeration we can perform only read
operation and we can’t perform any modify/removal operations.
To overcome these problems we should go for Iterator interface.
Iterator
o Introduced in 1.2 version.
o We can use Iterator Object for any collection implemented class i.e it is universal
cursor.
o By iterating the elements we can perform remove operation also in addition to

read operation.
This interface contains the following 3 methods.
boolean hasNext();
Object next();
void remove();
Ex:
import java.util.*;
class IteratorDemo
ArrayList al = new ArrayList();
for (int i =0;i<=10 ;i++ )
al.add(i);
}
System.out.println(al);
Iterator itr = al.iterator();
while (itr.hasNext())
Integer i = (Integer)itr.next();
if((i%2) == 0)
System.out.println(i);
else
itr.remove();
System.out.println(al);
Note:-
1. Enumeration and Iterator are single directional cursors. They can always move
to words forward direction only.
2. By using Iterator we can perform read and remove operations. And we can’t
perform any replace or addition of new objects
To over come these limitations we should go for ListIterator interface.
ListIterator
1.It has introduced in 1.2 version and it is child interface of Iterator.
2.It is a bidirectional cursor.
3.i.e Based on requirement we can move either to the forward or backward

direction.
4.While Iterating we can perform replace and add operation in addition to read and
remove this
interface defines the following 9 methods.
1. boolean hasNext();
2. boolean hasPrevious();
3. Object next();
4. Object previous();
5. int nextIndex();
6. int previousIndex();
7. void remove();
8. void set(Object)
nextIndex(): If there is no next element it returns size of the list.
previousIndex(): If there is no previous element it returns -1 .
import java.util.*;
class ListIteratorDemo
LinkedList l = new LinkedList();
l.add("balakrishna");
l.add("chiru");
l.add("venky");
l.add("nag");
ListIterator ltr = l.listIterator();
while (ltr.hasNext())
String s = (String)ltr.next();
if(s.equals("nag"))
{
ltr.add("chaitanya");
The most powerful cursor is listIterator. But it’s main limitation is it is appble only
for list
implemented classes (ArrayList, LinkedList, Vector, Stack).
SetInterface
This can be used for representing a group of Individual objects where insertion
order is not preserved and
duplicate objects are not allowed.
Set interface is child interface of Collection.
This interface doesn’t contain any new method and we have to use only collection
Interface methods.
HashSet( class)
The underlying Data Structure for HashSet is Hashtable.
Insertion order is not preserved and it is based on hash code of the Object.
Duplicate objects are not allowed. Violation leads to no CompileTimeError or

RuntimeError, boolean add(Object o)
Adds the specified element to this set if it is not already present.
This method simply returns false. If the object is already existing in the set.
HashSet is the best choice if the frequent operation is Search Operation.
Constructors
1. HashSet h = new HashSet()
Creates an empty HashSet object with default size

2. HashSet h = new HashSet(int initialcapacity)
3. HashSet h = new HashSet(int initialCapacity, float fillratio)
Here fillratio is 0 or 1.
HashSet h = new HashSet(Collection c)
Ex:
import java.util.*;
class HashSetDemo
HashSet h = new HashSet();
h.add("B");
h.add("C");
h.add("D");
h.add("Z");
h.add(null);
h.add(new Integer(10));
System.out.println(h.add("Z"));
System.out.println(h);
LinkedHashSet (class)
It is the child class of HashSet. It is Exactly similar to HashSet. Except the following
differences.
HashSet LinkedHashSet
1) The underlying Data Structure is 1) The underlying Data Structures are

Hashtable
Hashtable and LinkedList
2) Insertion Order is not preserved 2) Insertion Order is preserved.

3) Introduced in 1.2 version 3) Introduced in 1.4 version
In the above program if u r replacing ‘HashSet’ with ‘LinkedHashSet’ the following is

the output.
Note:- For implementing caching apption the best suitable Data structure is
LinkedHashSet and LinkedHashMap where duplicate objects are not allowed
and insertion order Must be preserved.
SortedSet
This can be used for representing a group of individual objects where duplicate
objects are not
allowed.
Insertion order is not preserved but all the elements are inserted according to
some sorting order
of elements. The sorting order may be default natural sorting order or customized
sorting order.
SortedSet Interface contains the following more specific methods
1. Object first()
Returns first element in the SortedSet
2. Object last()
3. SortedSet headSet(Object obj)
Returns the SortedSet contains the elements which are less than the specified
object obj.
4. SortedSet tailSet(Object obj)
Returns the SortedSet whose elements are greater than or equal to the specified
object obj
5. SortedSet subSet(Object obj1, Object obj2)
Returns the SortedSet whose elements are >= obj1 but < Obj2
6. Comparator comparator();
Returns the comparator object describes the underlying sorting technique.

If you are using default(Assending) natural sorting order it returns null.
first()  100
last()160
headSet(140)  {100,120,130}
tailSet(140) {140,150,160}
subset(130,150) {130,140}
comparator() null
TreeSet
The underlying Data structure for the TreeSet is Balanced tree.
Duplicate objects are not allowed. If we are trying to insert duplicate object we
won’t get any
compile time error or Run time error, add method simply returns false.
Insertion order is not preserved but all the elements are inserted according to
some sorting order.
Heterogeneous objects are not allowed, violation leads to Run time error saying
class cast
Exception
Constructors
1. TreeSet t = new TreeSet();
Creates an empty TreeSet Object where the sorting order is default natural sorting
order.
2. TreeSet t= new TreeSet(Comparator c)

Creates an empty TreeSet Object where the Sorting order is specified by
comparator
object.
3. TreeSet t= new TreeSet(Collection c)
4. TreeSet t= new TreeSet(SortedSet s)
Creates TressSet Object for a given SortedSet.
Ex:
import java.util.*;
class TreeSetDemo
TreeSet t = new TreeSet();
t.add("A");
t.add("B");
t.add("Z");
t.add("L");
//t.add(new Integer(10));// ? ClassCastException.
//t.add(null); //? NullPointerException.
t.add("A");// ? false.
System.out.println(t);
null Acceptance
For the empty TreeSet as the first element null insertion is possible. But after
inserting null if we are trying to insert any other element we will get
NullPointerException.
If the TreeSet already contains some elements if we are trying to insert null we will
get
NullPointerException.
Ex:
import java.util.*;
class TreeSetDemo
TreeSet t = new TreeSet();
t.add(new StringBuffer("A"));
t.add(new StringBuffer("B"));
t.add(new StringBuffer("T"));
t.add(new StringBuffer("Z"));
System.out.println(t);
O/P:- R.E: ClassCastException.
If we are depending on natural sorting order compulsory the objects should be

homogeneous and comparable other wise we will get class cast Exception.
An object is said to be comparable(if and only if) the corresponding class has to
implement
comparable interface.
All wrapper classes and String class already implemented comparable interface.
But the String buffer doesn’t implement comparable interface. Hence in the
above program we got class cast exception.
Queue interface
1) If we want to represent a group of individual objects prior (happening before something
else) to processing then we should go for Queue interface.
Diagram:
2) Usually Queue follows first in first out order but based on our requirement we can
implement our own order also.
3) From 1.5v onwards LinkedList also implements Queue interface.
4) LinkedList based implementation of Queue always follows first in first out order.
Queue interface methods:
1) boolean after(Object o);
To add an object to the Queue.
2) Object poll() ;
To remove and return head element of the Queue, if Queue is empty then we will get
null.
3) Object remove();
To remove and return head element of the Queue. If Queue is empty then this method
raises Runtime Exception saying NoSuchElementException.
4) Object peek();
To return head element of the Queue without removal, if Queue is empty this method
returns null.
5) Object element();
It returns head element of the Queue and if Queue is empty then it will raise Runtime
Exception saying NoSuchElementException

PriorityQueue:
1) We can use PriorityQueue to represent a group of individual objects prior to processing
according to some priority.
2) The priority order can be either default natural sorting order (or) customized sorting
order specified by Comparator object.
3) If we are depending on default natural sorting order then the objects must be
homogeneous and Comparable otherwise we will get ClassCastException.
4) If we are defining our own customized sorting order by Comparator then the objects
need not be homogeneous and Comparable.
5) Duplicate objects are not allowed.
6) Insertion order is not preserved but all objects will be inserted according to some
priority.
7) Null is not allowed even as the 1st element for empty PriorityQueue.
Constructors:
1) PriorityQueue q=new PriorityQueue();
Creates an empty PriorityQueue with default initial capacity 11 and default natural
sorting order.
2) PriorityQueue q=new PriorityQueue(int initialcapacity,Comparator c);
3) PriorityQueue q=new PriorityQueue(int initialcapacity);
4) PriorityQueue q=new PriorityQueue(Collection c);
5) PriorityQueue q=new PriorityQueue(SortedSet s);
Example 1:
import java.util.*;
class PriorityQueueDemo

{
PriorityQueue q=new PriorityQueue();
//System.out.println(q.peek());//null
//System.out.println(q.element());//NoSuchElementException
for(int i=0;i<=10;i++)
q.offer(i);
System.out.println(q);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
System.out.println(q.poll());//0
System.out.println(q);//[1, 3, 2, 7, 4, 5, 6, 10, 8, 9]
Note: Some platforms may not provide proper supports for PriorityQueue [windowsXP].
Example 2:
import java.util.*;
class PriorityQueueDemo
PriorityQueue q=new PriorityQueue(15,new MyComparator());
q.offer("A");
q.offer("Z");
q.offer("L");
q.offer("B");
System.out.println(q);//[Z, B, L, A]
}
class MyComparator implements Comparator
public int compare(Object obj1,Object obj2)
String s1=(String)obj1;
String s2=obj2.toString();
return s2.compareTo(s1);
Comparable interface:
Comparable interface present in java.lang package and contains only one method
compareTo() method.
public int compareTo(Object obj);
Example:
obj1.compareTo(obj2);
Diagram:
Example 3:
class Test

{
System.out.println("A".compareTo("Z"));//-25
System.out.println("Z".compareTo("K"));//15
System.out.println("A".compareTo("A"));//0
//System.out.println("A".compareTo(new Integer(10)));//Test.java:8:
compareTo(java.lang.String) in java.lang.String cannot be applied to (java.lang.Integer)
//System.out.println("A".compareTo(null));//NullPointerException
If we are depending on default natural sorting order then internally JVM will use
compareTo() method to arrange objects in sorting order.
compareTo() method analysis:
If we are not satisfying with default natural sorting order (or) if default natural sorting
order is not available then we can define our own customized sorting by Comparator
object.
Comparable meant for default natural sorting order.
Comparator meant for customized sorting order.

Comparator interface:
Comparator interface present in java.util package this interface defines the following 2
methods.
1) public int compare(Object obj1,Object Obj2);
Diagram:
2).public boolean equals(Objectobj);
Whenever we are implementing Comparator interface we have to provide
implementation only for compare() method.
Implementing equals() method is optional because it is already available from Object
class through inheritance.
Requirement: Write a program to insert integer objects into the TreeSet where the sorting
order is descending order.
Program:
import java.util.*;
class Test
TreeSet t=new TreeSet(new MyComparator());------------(1)
t.add(10);
t.add(0);
t.add(15);
t.add(5);
t.add(20);
System.out.println(t);//[20, 15, 10, 5, 0]
Integer i1=(Integer)obj1;
if(i1<i2)
return +1;
else if(i1>i2)
return -100;
else return 0;
At line “1” if we are not passing Comparator object then JVM will always calls
compareTo() method which is meant for default natural sorting order(ascending
order)hence in this case the output is [0, 5, 10, 15, 20].
At line “1” if we are passing Comparator object then JVM calls compare() method of
MyComparator class which is meant for customized sorting order(descending order)
hence in this case the output is [20, 15, 10, 5, 0].
Diagram:
Various alternative implementations of compare() method:
//return i1.compareTo(i2);//[0, 5, 10, 15, 20]
//return -i1.compareTo(i2);//[20, 15, 10, 5, 0]
//return i2.compareTo(i1);//[20, 15, 10, 5, 0]
//return -i2.compareTo(i1);//[0, 5, 10, 15, 20]
//return -1;//[20, 5, 15, 0, 10]//reverse of insertion order
//return +1;//[10, 0, 15, 5, 20]//insertion order
//return 0;//[10]and all the remaining elements treated as duplicate.
Requirement: Write a program to insert String objects into the TreeSet where the sorting
order
is reverse of alphabetical order.
Program:
import java.util.*;
class TreeSetDemo
{
TreeSet t=new TreeSet(new MyComparator());
t.add("Roja");
t.add("ShobaRani");
t.add("RajaKumari");
t.add("GangaBhavani");
t.add("Ramulamma");
System.out.println(t);//[ShobaRani, Roja, Ramulamma, RajaKumari,
GangaBhavani]
//return s2.compareTo(s1);
return -s1.compareTo(s2);
Requirement: Write a program to insert StringBuffer objects into the TreeSet where the
sorting
order is alphabetical order.
Program:
import java.util.*;
class TreeSetDemo
t.add(new StringBuffer("A"));
t.add(new StringBuffer("Z"));
t.add(new StringBuffer("K"));
t.add(new StringBuffer("L"));
System.out.println(t);// [A, K, L, Z]
Note: Whenever we are defining our own customized sorting by Comparator then the
objects
need not be Comparable.
Example: StringBuffer
Requirement: Write a program to insert String and StringBuffer objects into the TreeSet
where
the sorting order is increasing length order. If 2 objects having the same length then
consider
they alphabetical order.

Program:
import java.util.*;
class TreeSetDemo
t.add("A");
t.add(new StringBuffer("ABC"));
t.add(new StringBuffer("AA"));
t.add("xx");
t.add("ABCD");
t.add("A");
System.out.println(t);//[A, AA, xx, ABC, ABCD]
int l1=s1.length();
int l2=s2.length();
if(l1<l2)
return -1;
else if(l1>l2)
return 1;
else
Note: If we are depending on default natural sorting order then the objects should be
“homogeneous and comparable” otherwise we will get ClassCastException. If we are

defining
our own sorting by Comparator then objects “need not be homogeneous and comparable”.
Comparable vs Comparator:
For predefined Comparable classes default natural sorting order is already available if
we are not satisfied with default natural sorting order then we can define our own
customized sorting order by Comparator.
For predefined non Comparable classes [like StringBuffer] default natural sorting order
is not available we can define our own sorting order by using Comparator object.
For our own classes [like Customer, Student, and Employee] we can define default
natural sorting order by using Comparable interface. The person who is using our class,
if he is not satisfied with default natural sorting order then he can define his own sorting
order by using Comparator object.
Example:
import java.util.*;
class Employee implements Comparable
String name;
int eid;
Employee(String name,int eid)
this.name=name;
this.eid=eid;
public String toString()

{
return name+"----"+eid;
public int compareTo(Object o)
int eid1=this.eid;
int eid2=((Employee)o).eid;
if(eid1<eid2)
return -1;
else if(eid>eid2)
return 1;
else return 0;
class CompComp
Employee e1=new Employee("nag",100);
Employee e2=new Employee("balaiah",200);
Employee e3=new Employee("chiru",50);
Employee e4=new Employee("venki",150);
Employee e5=new Employee("nag",100);
TreeSet t1=new TreeSet();

t1.add(e1);
t1.add(e2);
t1.add(e3);
t1.add(e4);
t1.add(e5);
System.out.println(t1);//[chiru----50, nag----100, venki----150, balaiah----200]
TreeSet t2=new TreeSet(new MyComparator());
t2.add(e1);
t2.add(e2);
t2.add(e3);
t2.add(e4);
t2.add(e5);
System.out.println(t2);//[balaiah----200, chiru----50, nag----100, venki----150]
Employee e1=(Employee)obj1;
Employee e2=(Employee)obj2;
String s1=e1.name;
String s2=e2.name;
Comparision of Comparable and Comparator?

Comparable Comparator
1) Comparable meant for default natural 1) Comparator meant for customized
sorting order. sorting order.
2) Present in java.lang package. 2) Present in java.util package.
3) Contains only one method. 3) Contains 2 methods.
compareTo() method. Compare() method.
Equals() method.
4) String class and all wrapperClasses 4) No predefined class implements

implements Comparable Comparator.
interface.
Map Interface
If we want represent a group of objects as a key value pairs then we should go for
Map interface.Both key and and value are objects only.
Duplicate keys are not allowed but values can be duplicated.
Each key-value pair is called entry
There is no relation between Collection and Map
Collection meant for group of individual objects and Map is meant for group of key-
value pairs
Map interface is not child interface of Collection.

Each key-value pair considered as Entry object hence Map is
nothing but a set of entries.
Methods of Map interface:
1.Object put(Object key,Object value);
To add key-value pair to the map
If the specified key is already available then old value will be
replaced with new value and old value will be returned.
If the entry is added to the map then this method will return
null
2.void PutAll(Map m)
To add a group of key-value pairs
3.Object get(Object key)
Returns the value associated with specified key
If the key is not available then we will get null
4.Object remove(Object key)
5.boolean containsKey (Object key)
6.boolean containsValue (Object key)
7.int size();
8.boolean isEmpty();
9.Void clear()
Entry(Interface):
Each key-value pair is called one entry
Without existing Map object there is no chance of Entry
Object
HashMap
The underlying data structure for HashMap is Hashtable.
Duplicate keys are not allowed but values may be
duplicated.
Heterogeneous objects are allowed for both keys and values.
null is valid for both key and value
insertion order is not preserved because it is based on
Hashcode of keys
null key is allowed(only once)
null values are allowed (any no of times)
Difference between HashMap and Hashtable
HashMap Hashtable
No method is synchronized in All methods are

HashMap synchronized in
Hashtable
HashMap object is not thread Hashtable object is thread

safe safe
null is allowed for both key and null is not allowed for both
value key and value
HashMap is non-legacy class Hashtable is legacy class and

and introduced in 1.2v introduced in 1.0v
Constructors of HashMap
Construcor Description
HashMap hashMap=new Creates an empty HashMap

HashMap() object with default initial
capacity 16 and default
fill ratio 0.75
HashMap hashMap=new
HashMap(int
initialCapacity)
HashMap hashMap=new
HashMap(int
initialCapacity,float
fillratio)
HashMap hashMap=new
HashMap(Map map)
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {

HashMap map = new HashMap();
map.put("Gosling", 900);
map.put("Davidson", 800);
map.put("Bloch", 500);
map.put("Mcclanahan", 700);
System.out.println(map.put("Bloch", 678));
System.out.println(map);
// getting keys from HashMap
Set set = map.keySet();
System.out.println(set);
// getting values from HashMap
Collection collection = map.values();
System.out.println(collection);
// getting entries from HashMap
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry mapEntry = (Map.Entry) iterator.next();
System.out.println(mapEntry.getKey() + "--" +
mapEntry.getValue());
if (mapEntry.getKey().equals("Gosling")) {
mapEntry.setValue(2000);
}
}
}
}
LinkedHashMap
LinkedHashMap is a child class of HashMap and
LinkedHashMap is exactly similar to the HashMap
except the following differences.
HashMap LinkedHashMap
The underlying data The underlying data structure is a

structure is combination of Hashtable and
Hashtable LinkedList
insertion order is not insertion order is preserved

preserved
introduced in 1.2v introduced in 1.4v
IdentityHashMap
In the case of HashMap to identify duplicate keys JVM
always use .equals() method of string class(compares
the content).
But in the case of IdentityHashMap instead of .equals()
method JVM will use == operator (compares the hash
code or memory reference) to identify duplicate keys.
import java.util.IdentityHashMap;
public class IdentityHashMapDemo {

//HashMap implementation
HashMap map=new HashMap();
Integer i1=new Integer(100);
map.put(i1, "JAVA");
map.put(i2, "PHP");
//IdentityHashMap implementation
IdentityHashMap identityHashMap=new
IdentityHashMap();
identityHashMap.put(i1, "JAVA");
identityHashMap.put(i2, "PHP");
System.out.println(identityHashMap);
}
}
WeakHashMap
In the case of HashMap an object is not eligible for garbage
collector even though it doesn’t contain any external
references if it is associated with HashMap.
In the case of WeakHashMap an object is eligible for garbage
collector if it doesn’t contain any external references
even though it is associate with WeakHashMap.
That is HashMap dominates the garbage collector where as
garbage collector dominates the WeakHashMap.
import java.util.WeakHashMap;
public class WeakHashMapDemo {
public static void main(String[] args)throws

InterruptedException {
//HashMap implementation.
HashMap map=new HashMap();
Demo d=new Demo();
map.put(d, "JAVA");
d=null;
System.gc();
Thread.sleep(5000);
//WeakHashMap implementation.
WeakHashMap weakHashMap=new WeakHashMap();
Demo d1=new Demo();
weakHashMap.put(d1, "JAVA");
System.out.println(weakHashMap);
d1=null;
System.gc();
Thread.sleep(5000);
System.out.println(weakHashMap);
}
class Demo{
public String toString(){
return "demo";
}
public void finalize(){
System.out.println("Demo::finalize");
}
}
SortedMap
If we want arrange all entries according to some
sorting order of keys then we should go for
‘SortedMap’.
SortedMap interface defines the following 6 specific
methods.
Object firstKey()
Object lastKey()
SortedMap headMap(Object key)
SortedMap tailMap(Object key)
SortedMap subMap(Object key1,Object key2)
Comparator comparator()
TreeMap
The underlying data structure is RED-BLACK tree.
Duplicate keys are not allowed values can be duplicated.
Insertion order is not preserved and it is based on sorting
order of keys
If we are depending on natural sorting order,The keys
should be homogenous and comparable other wise we
will get ClassCastException.
If we are defining out own sorting by Comparator then keys
can be heterogeneous need not be Comparable.
There are no restrictions on values these can be
heterogeneous.
null insertion in TreeMap
If we are trying to insert null key in non empty TreeMap we
will get NullPointerException.
For the empty TreeMap as the first entry with null key is
allowed.But after inserting that entry if we are trying to
insert any other entry we will
get NullPointerException.
For the values no restrictions ,We can use any number of
nulls.
Constructors:
Constructor Description
TreeMap map=new TreeMap() It is used for natural

sorting order.
TreeMap map=new It is used for customized

TreeMap(Comparator) sorting order.
TreeMap map=new
TreeMap(Map)
TreeMap map=new
TreeMap(SortedMap)
import java.util.TreeMap;
public class TreeMapDemo {

TreeMap map=new TreeMap();
map.put("Gosling",1000);
map.put("Davidson",2000);
map.put("Mcclanahan",500);
map.put("Bloch",null);
//map.put(890,"James");//java.lang.ClassCastException:
java.lang.String cannot be cast to java.lang.Integer.
//map.put(null,"JAVA");//java.lang.NullPointerExceptio
n
}
}
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMapDemo {

TreeMap map=new TreeMap(new ComaratorDemo());
map.put("Gosling",1000);
map.put("Davidson",2000);
map.put("Mcclanahan",500);
map.put("Bloch",null);
}
}
class ComaratorDemo implements Comparator{
public int compare(Object obj1,Object obj2){

}
}
Java Streams
Java I/O (Input and Output) is used to process the input and produce the output
based on the input.
Java uses the concept of stream to make I/O operation fast. The java.io package
contains all the classes required for input and output operations.
We can perform file handling in java by java IO API.
A stream is a flow of data from source to destination
A Source can be a keyboard, file, server, client…etc
A destination can be monitor, file, client , server…etc
In java, streams are devided into three catogiries
1.Console Input/Output Streams
2.File Input/Output streams
3.Network Input/output streams

There are 3 predefined streams in java they are
1.in
2.out
3.err
1.in—it is an object reference of java.io.InputStream class
2.out &err—these are object references of java.io.PrintStream class
Note: the above all streams are defined as a static members in java.lang,System
class
Java.lang.System
Object references:
Public static final java.io.InputStream in;
Public static final java.io.PrintStream out;
Public static final java.io. PrintStream err;
File
A java file object represent just name of the file/directory.
File f = new File(“abc.txt”);
If ‘abc.txt’ is already available then ‘f’ will represent that physical file.
If it is not already available, It won’t create any new file and ‘f’ simply represents
the name of the file.
Ex:
import java.io.*;
class test
File f = new File("cba.txt");
System.out.println(f.exists()); false at first time.
f.createNewFile();
System.out.println(f.exists()); true
I Run:
false
true
II Run:
true
true
A java file Object can represent directories also
Ex:
File f = new File("bbc");
System.out.println(f.exists());
f.mkdir();
I Run:
false
true
II Run:
true
true
The constructors of the file class
1) File f = new File(String name)
Here name may be file or directory name. Creates a java file object that represents a
file or directory name.
2) File f = new File(String directoryname, String subdirectory/filename)
Creates a java file object that represents file or directory name present in specified
subdirectory.
File f = new File(File directoryname, String filename/directoryname)
import java.io.*;
class Test
public static void main(String[] args)throws Exception
File f1=new File("d:\\ccccccccccc");
f1.mkdir();
File f = new File(f1, "abcd.txt");
f.createNewFile();
Important methods of File Class

1) boolean exists():
returns true if the physical file/directory presents other wise false.
2) boolean createNewFile():
returns ture if it creates a new file, if the required file is already available then
it won’t create any new file and returns false.
3) booelan mkdir()
For creation of directory.
4) boolean isFile():
returns true if the java file object represents a file.
5) boolean isDirectory():
returns true if the java file object represents a directory.
6) String [] list():
returns the names of files and directories present in the directories represented
by the file object.
If the java file object represents a file instead of directory this method returns
null.
7) Boolean delete():
for deleting the file or directory represented by java file object.
8.long length();
Returns the no characters that are present in the specified file
write a program to create a file named with ‘xyz.txt’ in the current working
directory.
File f = new File(“xyz.txt”);
f.createNewFile();
Write a program to create a directory ‘raju123’ in the current working directory

and create a
file ‘file1.txt’ in that directory.
File f = new File(“raju123”);
f.mkdir();
// File f1 = new File(“raju123”,”file1.txt”);
File f1 = new File(f,”file1.txt”);
F1.createNewFile();
Write a program to list the names of files and directories in ‘jdk’ directory.
File f = new File(“jdk”);
String [] s = f.list();
For(String s1: s)
FileWriter
This class can be used for writing character data to the file.
Constructors
1) FileWriter fw = new FileWriter(String fname)
2) FileWriter fw = new FileWriter(File f);
The above 2 constructors creates a file object to write character data to the file.
If the file already contains some data it will overwrite with the new data.
Instead of overriding if u have to perform append then we have to use the following
constructors.
FileWriter fw = new FileWriter(String name, boolean append);
FileWriter fw = new FileWriter(File f, boolean append);
If the underlying physical file is not already available then the above constructors
will create the required file also.
Important methods of FileWriter Class

1) void write(int ch) throws IOException
for writing single character to the file.
2) void write(String s)throws IOException.
To write String to the specified file
3) void write(char [] ch) throws IOException.
To write an array of characters to the file

void flush():-To guaranteed that the last character of the data is also writtent to the
file.
Close():- to close the file
Ex:-
class test
public static void main(String arg[])throws Exception
File f = new File("pongal.txt");
FileWriter fw = new FileWriter(f,true);
fw.write(97);//adding a single character
fw.write("run\nsoftware\n");
fw.write(‘\n’);
char [] ch1 = {'a','b','c'};
fw.write(ch1);
fw.flush();
fw.close();
FileReader
This class can be used for reading character data from the file.
Constructors
1) FileReader fr = new FileReader(String name);
2) FileReader fr = new FileReader(File f);
Important methods of FileReader Class

1) int read():
for reading next character from the file and returns it Unicode character value. If
there is no next character this method returns -1
2) int read(char[] ch): it attempts to read no of characters from file into array and
returns the no of characters which are read from the file.
3) void close():
to close FileReader
Ex:
class test
FileReader fr = new FileReader(f);
System.out.println(fr.read());
char [] ch2 = new char[(int) (f.length())];
System.out.println(ch2.length);
fr.read(ch2);
for(char ch1: ch2)
System.out.print(ch1);
System.out.println(“************”);
FileReader fr1=new FileReader(f);
Int i=fr1.read();
While(i!=-1)
System.out.println((char)i);
I=fr1.read();
}
}
The usage of FileReader and FileWriter is in efficient because
While writing the data by using FileWriter, programmer is responsible to insert

line separators manually.
We can read the data character by character only by using FileReader. If

increases the number of I/O operations and effect performance.
To overcome these problems sun people has introduced BufferedReader and

BufferedWriter classes.
BufferedWriter
This can be used for writing character data to the file.
Constructors
1) BufferedWriter bw = new BufferedWriter(writer w)
2) BufferedWriter bw = new BufferedWriter(writer r, int size)
BufferedWriter never communicates directly with the file. It should Communicate

through
some writer object only.
Q) Which of the following are valid declarations
1) BufferedWriter bw = new BufferedWriter(“abc.txt”); X
2) BufferedWriter bw = new BufferedWriter(new File(“abc.txt”)); X
3) BufferedWriter bw = new BufferedWriter(new FileWriter(“abc.txt”));
4) BufferedWriter bw = new BufferedWriter(new BufferedWriter(new
FileWriter(“abc.txt”)));
Important methods of BufferedWriter Class

1) void write(int ch) thorows IOException
2) void write(String s) throws IOException
3) void write(char[] ch) throws IOException
4) void newLine()
for inserting a new line character.

5) void flush()
6) void close()
Ex:-
class test
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
bw.write(97);
bw.newLine();
char [] ch1 = {'a','b','c','d'};
bw.write(ch1);
bw.newLine();
bw.write("raju");
bw.newLine();
bw.write("software");
bw.flush();
bw.close();
Note: when ever we are closing BufferedWriter automatically under lying writers
will be closed
BufferedReader
The advantage of BufferedReader over FileReader is we can read the data line by
line instead of reading character by character. This approach improves the
performance of the system by reducing the no of read operations
Constructors
1) BufferedReader br = new BufferedReader(Reader r)
2) BufferedReader br = new BufferedReader(Reader r, int buffersize)
BufferedReader never communicates directly with the file. It should Communicate

through
some reader object only.
Important methods of BufferedReader Class
1) int read()
2) int read(char [] ch)
3) String readLine();
Reads the next line present in the file. If there is no nextline this method returns
null.
4) void close()
Ex:
class test
FileReader fr = new FileReader("pongal.txt");
BufferedReader br = new BufferedReader(fr);
String s = br.readLine();
while(s != null)
s = br.readLine();
}
Note:- When ever we r closing BufferedReader ,automatically underlying
FileReader object will be
closed.
types of streams:
===============
1.Byte streams
2.Character streams
1.Byte streams:
these streams handle text,image graphics,animation,audio,video...etc
2.Character streams:
these streams handle only text type of data(characters)
DataInputStream and DataOutputStream classes support all primitive data types

and Strings.
ObjectInputStream and ObjectOutputStream classes support objects.
The hierarchy of byte stream classes:
object
InputStream OutputStream
The hierarchy of character stream classes:
object
Reader Writer
BufferedReader InputStreamReader
BufferedWriter Printwriter
OutputStreamWriter
FileReader
FileWriter
java.io.InputStream
================
methods:
public int read(byte[])throws java.io.IOException;
==> it is used to accept data from keyboard
//program to demonstrate
import java.io.*
class Demo
try
byte b=new byte[10];
System.out.println("enter any number:");
System.in.read(b);
String s1=new String(b);
String s2=s1.trim();
int x=Integer.parseInt(s2);
System.out.println(x);
catch(IOException ie)
System.out.println(ie);
}
}
FileInputStream
FileInputStream class possesses the functionality of reading one byte at a time from
a file.
java.io.FileInputStream
================
constructor:
public FileInputStream(String) throws FileNotFoundException;
==> it opens a file for reading if the file is exist, otherwise FileNotFoundException
will be thrown
methods:
1.public int read(byte[])throws java.io.IOException;
==> it is used to accept data from keyboard
2.public native int available() throws IOException;
it returns file size
3.public void close() throws IOException;
steps to develop apption
1.open a file for reading
2.find out file size
3.allocate memory in Ram according to file size
4.read data from file
5.display data on monitor.
6. close a file.
import java.io.*
class ReadDemo
try
int n=fis.available();
byte b=new byte[n];
fis.read(b);
String s=new String(b);
catch(Exception ie)
FileOutputStream:
FileOutputStream class possesses the functionality of writing one byte at a time into
a file.
java.io.FileOutputStream
================
constructor:
public FileOutputStream(String) throws FileNotFoundException;

==> it opens a file for writing if the file is exist, otherwise FileNotFoundException
will be thrown
public FileOutputStream(String,boolean) throws FileNotFoundException;
==> it opens a file in append mode
methods:
1.public void write(byte[])throws IOException;
2.public void close()throws IOException;
note: in write mode existing data will be erased
steps to develop apption
1.open a file for reading
2.find out file size
3.allocate memory in Ram according to file size
4.read data from file
5.open a file for writing or appending
6.write data to a file
7. close a file.
import java.io.*
class CopyDemo
try
int n=fis.available();
byte b=new byte[n];
fis.read(b);
FileOutputStream fos=new FileOutputStream(args[1],true);
fos.write(b);
catch(Exception ie)
PrintWriter
This is the most enhanced writer to write character data to the file . by using
filewriter and bufferedwriter we can write only character data but by using
printwriter we can write any primitive datatypes to the file also
The most enhanced writer for writing character data to the file is PrintWriter
Constructors
1) PrintWriter pw = new PrintWriter(String fname)
2) PrintWriter pw = new PrintWriter(File f);
3) PrintWriter pw = new PrintWriter(Writer w);
Important methods
1) write(int ch)
2) write(char [] ch)
3) write(String s)
4) print(int i)
print(double d)
print(char ch)
print(Boolean b)
print(char ch[])
5) void flush()
6) close()
Ex:
class test
FileWriter fw = new FileWriter("pongal.txt");
PrintWriter out = new PrintWriter(fw);
out.write(97);
out.println(100);
out.println(true);
out.println('c');
out.println("FDGH");
out.flush();
out.close();
Serialization Introduction
Serialization: The Process of Saving an object to a file is called “serialization”. But
strictly speaking
serialization is the process of converting an object from java supported format to

network or file supported
format.
By using FileOutPutStream, ObjectOutPutStream classes we can achieve

serialization
Deserialization: The process of reading an object from a file is called
deserialization. But strictly speaking it
is the process of Converting an object from network supported format or file

supported format to java
supported format.
By using FileInputStream, ObjectInputStream we can achieve deserialization.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Dog implements Serializable {

int i=10;
int j=20;
public class SerializeDemo {
public static void main(String[] args)throws Exception {
//Serialization
Dog d=new Dog();
FileOutputStream fos=new FileOutputStream("abc.ser");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(d);
//De-Serialization
FileInputStream fis=new FileInputStream("abc.ser");
ObjectInputStream ois=new ObjectInputStream(fis);
Dog d2=(Dog)ois.readObject();
System.out.println(d2.i+"----"+d2.j);
/*
Output:
10----20
*/
We can perform serialization only for serializable objects.An object is said to be

serializable if only if the corresponding class should implement Serializable
interface.
Serializable interface is defined in java.io package and doesn’t contain any method
,It is a marker inetrface.
If we are trying to perform serialization of non-serializable objects,We will get
RuntimeException saying “NotSerializableException“.
At the time of serialization,If you don’t want to send the value of a particular
variable,We have to declare that variable as transient.
At the time of serialization ,JVM ignores the original value of transient variable and
send default value.i.e transient means not to serialize.
static variables are not part of the object,Hence they won’t participate in
serialization process.
As static variables won’t participate in serialization,declaring static variable as

transient there is no impact.
Similarly,declaring final variable as transient there is no impact.
Declaration Output
int i=10; 10—20

int j=20;
transient int i=10; 0—20

int j=20;
transient static int i=10; 10—0

transient int j=20;
transient final int i=10; 10—0

transient int j=20;

My Java Notes

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

My Java Notes

Enviado por

Direitos autorais:

Formatos disponíveis

Java

Java is a technology and it has 2 things

Apption: an apption is a program in which we interact with on the desktop.

1.stand alonone apptions

A stand alone apption is an apption which runs on only one system

A distributed apption is an apption which runs on two or more systems

Types of stand alone apptions:

1.console apptions:(character user interface (CUI))

2.window apptions(Graphical user interface(GUI)

a console apption is an apption in which we interact with commands by using keyboard

a window apption is an apption in which we interact with keyboard and mouse

Ex: Ms-word,Ms-excel, Ms-powerpoint….etc

Types of distributed apption:-

Types of web apptions:

1.static web apptions

2.dynamic web apptions

1.Static web apption:

2. Dynamic web apptions:

An enterprise apption is a distributed apption which performs business functions.

Ex: ATM banking, Railway reservation system…etc

A service is a process and process is an instance of .exe file

Ex: Notepad Notepad

Services used by apptions to run under operating system.

2. Web service: it is a method of communication b/w 2 electronic devices

Platform: it can be a software or hardware environment in which program runs

There are 4 java platforms:

it is a platform designed for embedded systems. Embedded devices are industrial

The JVM performs following main tasks:

Provides runtime environment

Declaration rules for a source file(.java)

A source file can have any no of non public classes.

Java notations : (java coding standards)

Temporary path setting:

C:\> set path=”%path%”.; C:\Program Files\Java\jdk1.5.0_21\bin;

1) A java identifier is a sequence of characters, where each character may be a letter

symbol we will get Compile time error “IllegalCharacter”.

2) Identifier should not be starts with digit.

4) Java Identifiers are case sensitive

5.reserve words cannot be used as identifiers.

It determines what value a variable can hold

In java data types are devided into 2 types

1.primitive data types

2.reference data types

1.primitive data types:

byte 1 -128 to 127 0

short 2 -32768 to 32767 0

int 4 -2147483648 to 2147483647 0

long 8 -231 to 231-1 0

float 4 -3.4e38 to 3.4e38 0.0

double 8 -1.7e308 to 1.7e308 0.0

char 2 0 to 65535 Single space character

boolean NA Not Appble False

Literal is a constant value assigned to the variables.

Decimal literals: allowed digits are 0 to 9

should be prefixed with 0x or 0X

public static void main(String arg[])

System.out.println(x + "..." + y + "..." + z);

Note: By default every integral lateral is of int datatype

An integral literal is of long type should suffixing with l or L.

Floating – point literals

with ‘f’ or ‘F’.

A. float f = 10.5; X C.E possible loss of precision

A variable is a container which contains data