Core Java Ex 1

Identifier
A name in a java Program is called an Identifier.Which can be

used for representing classes, methods, variables and labels.
Rules:
1.Java Identifier is composed of a sequence of charaters,Which each
charater may be a letter from a to b or A to B or digit from 0 to 9 or
currency symbol ($) or connecting symbol (_).If we use other charater
we will get commpail time error saying illegal charater.
2. No identifier starts with the digit.
3. There is no length limit for java identifier, but SUN highly
recommened upto 15 charaters .
4. Identifier in java are casesensitive.
5. We are not allowed to use reserved words as identifier.
6. All predefined java class names, you are allowed to use as
identifiers.
Examples:
Total (√)
total123 (√)
123total (×)
total$ (√)
_total (√)
total# (×)
total_numbers (√)
total-numbers (×)
Java KeyWords
Some identifiers are reserved in Java which has saparate functionality
and meaning such type of reserved indentifiers are called reserved
words.
53 reserved words are there in java
50 are keywords-----------48 used keywords, 2 unused keywords
(goto,const)
3 reserved literals----------true,false,null
Keywords for premitive datatypes:
*byte *short *int *long *float *double
*char *boolean
Keywords for fow control:
*if *else *switch *case *default *for
*do *while *break *continue *return
Keywords for Exception Handling:
*try *catch *finally *throw *throws *assert
Keywords for modifiers:
*public *private *protected *static *abstract *strictfp
*final *transient *native *volitle *synchronised
Class related key words:
*class *interface *package
*extends *implements *import
Object related key words:
*new *instanceOf *super *this
Other:
Void
Unused keywords: *const *goto
Example:
class KeyEx1
{
int goto=10; ←---------------here we will get identifier expected error
}
Reserved literals:
*true *flase *null
New key words in j2SE 1.5: *enum
All the key words contains only lower case alphabate symbols
Java Data Types
In java any variable has a type, any express as a type and every type
is strictly defind.Compiler will check all asignments for type
compatability .Hence java is considered as strong typed language.
Java Language is not considered as pure oop language because some
non-object (primitive data types) we have to maintain in our code sun
people has interduced wrapper class to convert primitive to object
form.
Data type --------------------- Wrapperclass

byte ------------------------- Byte
short ------------------------- Short
char ------------------------- Character
int ------------------------ Integer
float ------------------------ Float
double ----------------------- Double
boolean ---------------------- Boolean
long ----------------------- Long
Primitive types:
Numeric types:
Integral types for whole numbers
byte short int long
Floating point data types:
float double
char for character data type
boolean for logical values
except boolean and char the remaining data types are signed
datatypes. Ie. we can represent both positive and negative numbers
by using numerical datatype.
java byte Datatype :

size---------8bits or 1 byte
range------ -128 to +127
native numbers are represented in 2’s complement form
this data type is best suitable of your handling data in terms of
streams from a file or network
byte b=100; (valid)
byte b=200; (invalid)-----PLP found int required byte
short Datatype:
size------------16 bits or 2 bytes
range--------- -2 pow 15 to + 2 pow 15-1 i.e -32768 to 32767
this data type is very rarely used type in java.but best suitable for 16
bit process(these 16 bit processer are completely out dated and hence
also the short data type is out dated now a days)
int data type:

size----------- 32 bits or 4bytes
range-------- -2 pow 31 to 2 pow 31-1 i.e -2147483648 to +2147483648
in c language the size of int is varied from platform to platform .the c
program written for 32 bit proccesser can not run on 16 bit
processor.hence chance of failing of c programe is very high .if we
change plaiform. As a result c is not considered as a robust language.
But in the case of java the size of any data type is fixed for any
platform. Hence chance of failing of java program is very very class. If
we change platform As a result java is considered as a robust
language.
Long datatype:
Size----------64 bits or 8bytes
Range------- -2 pow 63 to 2 pow 63 -1
If int is not enough to hold big values like the amount of distence
trvelled by light in 1000 days,we shoud go for long datatype only.
Float datatype:
Size--------------32bits or 4 bytes
Range---------- -3.4e38 to + 3.4e38
For 6 to 7 decimal places of accuracy , we should for float data type.so
this is less accuracy.
Double datatype:
Size--------------64bits or 8 bytes
Range---------- -1.7e308 to + 1.7e308
For 14 to 15 decimal places of accuracy , we should for double data
type.so this is more accurency.
Boolean datatype:
The size of boolean is not applicable.(it is purely depend on the
underlying jvm).range not applicable.
But allowed values are true or flase. TRUE or FALSE are not allowed.
Char datatype:
Size--------------16 bits or 2 bytes.
Range----------- 0 to 65535.
This is to providing unicodes for all the worldwide charater sets.
java Literals
A constant value which can be assigned to a variable is known
as Literal.If we are assigning any outside range value for any data
type, we will get a compile time error saying Possible Loss of Precision
found int required byte.
For the integral data types (int, byte, short, long): we are allowed to
specify a literal value of any any one of the following three forms.
---> Decimal literal (normal way)
--->Octa literal (prefixed with 0 )
--->Hexa decimal (prefixed with 0x )
int x=10 ------------> Decimal

int x=010 ------------>Octa
int x=0X10 -------------->Hexa
In the Hexa decimal notation for the extra digits we are allowed to
specify either small or upper case a,b,c or A,B,C (this is one of the few
places where java is not case sensitive).
Example:
class Sample {
public static void main(String add[]) {
int i = 10;
int j=010;
int k=0x10;
System.out.println( i+”….”+j+”…”+k);
}}
Output: 10,8,16
JVM gives only decimal form as output regardless of input as octa or
hexa.
All the integral literals (decimal.octa,hexa) are by default int.
We can specify explicitly a long literal by suffixing l or L.
There is no direct way to specify the short,byte values.
Assigning chart (Possible assignments):
With out final compiler gives error .with final is possible because int
has 4 bytes by declaring it final and that literal (10) is with in the size
of byte.
int Literal Example:

class Literalone {
public static void main(String ass[]) {
int i='a';
byte b1='b';
char ch='b';
//byte b=ch; ---------->error (PLP found : char required: byte
System.out.println(i); -------------> output is 97
//System.out.println(b);
}}
floating Point Literal:

The floating point literals by default double.
Ex: float f=123.453; ----------> is invalid
Got error as PLP required :float found:double
A floating point literal can be specified as float type by suffixing with f
or F
Example:
float f=128.453f or F (valid)
float f=123.456; (not valid)
double d=123.456; (valid)
double d=123.453f; (valid)
double d=123.345d or D; (valid)
A floating point literal can be explicitly double by suffixing with D or d;
float f=123.56d; (not valid)
A floating point literals must always specify in the decimal form only
.there is no hexa decimal or octal form.
float f=123.0; (not valid)
float f=123; (valid)
float f= 0123; (valid)
float f=0x123; (valid)
We can assign an integral literal (decimal,octal,hexa) to the float data
type directly (*no need to specify the f or F).
We can’t assign a floating point literal to the integral types.
int i=123.34 (not valid)
boolean Literal:
boolean valid literals are true or flase
boolean b=10; (not valid error PLP found:int reqired :boolean)
char literals:
A char literal can be specified as a single charter in single codes.
Ex: char ch=’@’; (valid)
char ch=a; (not valid)
char ch=’ad’; (not valid) error unclosed character literal.
An integral literal which represents the Unicode value of the character.
Ex: char ch=97; output: a
The valid integral literals must be from 0 to 65535.
for the Unicode values which are not sported by the system,we get ‘?’
as output.
char ch=0x(face) (valid)
char ch=ox61; output:1
The Unicode may be in octal /hexa decimal form.
char ch=97 ;
char ch= ‘a’;
char ch= 0x61;
char ch=’\uXXXX’; --------------------->Unicode representation
Ex: char ch=’\u0061’; output=a;
Unicode representation in nothing but \u followed by 4 digit
hexadecimal number .(only small u,capital u is not allowed).
char ch=’\uface’; valid output: ?
char ch=’\ubeef’; valid
char ch=\ubeef; invalid ‘ ‘ missed.
char ch=’\ibeef’; invalid u missed.
Escape charater
Ex: char ch=’\b’; valid
char ch=’\t’; valid
char ch=’\n’; valid
char ch=’\f’; valid
char ch=’\k’; not valid
Escape sequences:
unicode value charater
\u0008 backspace
\u0009 horizental tab
\u000a new line
\u000d carriage return
\u000c form feed
\u0027 single quote
\u0022 double quote
\u005c back space
String literal:
Instead of \n and /r we are not allowed to the corresponding unicode
charater \u000a and \u000d
Vailation leads to compail time error ever in the comments also.
String s=” laxman scjp”; (valid)
String s=”laxman \n scjp”; (valid)
String s=”laxman \t scjp”; (valid)
String s= “laxman \u0009 scjp”; (valid)
String s= “laxman \u000a scjp”; (not valid) gives error illegal escape
character
String s=”laxman \u000d scjp”; (not valid) gives error illegal eacape
chracter
Java Variables
Depends on the content hold by the variables are divided into two
categories.
1. Reference variable
2. Primitive variable
reference variable can be used to hold object references.
Ex: String s=”Laxman”;
Here s is a String object
Primitive variable can be used to hold primitive values.
Example: int i=10;
int[][] a={{1,2},{3,4,5},{6,7,8,9},{}};
for(int i=0;i <= a ;i++)
System.out.println(a[i].length);
}
output: 2,3 ,4,0
Depends on the position at which it is declared all the
variables divided into 3 categories.
1.instance variables/attributes/member variables
2.static variables
3.local variables
Example:
class Student {
String name;
int rollno;
public static void main(String arg[]) {
Student s=new Student();
}
}
Instance variables:
If the values of the variables are varied from instance to instance3,
such type of variables are called instance variables.We can declare
instance variables with in class ,but outside of any method or
block.These are also known as attributes /properties/member
variables.The instance variable will create when ever an object
is created and destroyed ,whenever garbage collection
destroys this object.Instance variable will get default variable
no need to perform ,explicit initialization.
Static variables:
A single copy of the static variable will maintain and shared by
all instances .the value of the static variable is the same for
the all instances.The static variable will create whenever the
class loaded into the memory and destroy whenever the class
is unloaded from the memory.These variables are also known
as fields.
Example:
class Student {
String name;
int rollno;
static String collname;
Public static void main(String arg[]) {
Student s1=new Student();
System.out.println(s1.name); // null
System.out.println(collname); // null
}
}
With out s1 and static Compile time error
Static variables will get default values .No need to perform explicit
initialization.
System.out.println(Student.collname);
System.out.println(s1.collname);
Static variables we can access by using either class name
(highly recommended) or by using object reference.
Local variables:
The variables which are declared inside a method or block or
constructor or as method argument are called local variables.Also
known as temporary variables /stack variable/automatic
variables.The local variables will create as the part of the method
execution and will destroy when ever the method terminates.The
local variables never get default values and must be initialized
before using that local variable.Violation leads to CTE saying
variable I might not have been initialized.
Example:
case1:
class Sample{
public static void main(String arg[]){
int i;
System.out.println(”hello”); // hello
}}
Case2: class Sample{
int i;
System.out.println(i); // CTE variable I might not have been initialized.
}}
Case3: class Sample {
int i=10;
System.out.println(i); // 10
}}
Case4: class Sample {
int i;
if(arg.length>0) {
i=20;
}
System.out.println(i); // error
}}
It is not recommended to initialized local variable with in the logical
blocks .(But legal)
Case 5:class Sample {
int i;
if(arg.length>0) {
i=20;
}
else{
i=40;
}
System.out.println(i); // valid
}}
Case6: class Sample{
int[] a;
Sample s=new Sample();
System.out.println(s.a); // null
System.out.println(a) // error
System.out.println(s.a[0]); //RTE ---> null pointer exception
System.out.println(a.length); // RTE ---> null pointer exception
}}
case 7: If we declare as static int [] a;
System.out.println(a) // null
System.out.println(a[0]); //RTE ---> null pointer exception
System.out.println(a.length); // RTE ---> null pointer exception
Case8: static int [] a =new int[6];
System.out.println(a) // [I@add234]
System.out.println(a[0]); //0
System.out.println(a.length); //6
}
case9: class Sample {
int [] a;
System.out.println(a); // error
System.otu.println(a[0]);
System.out.println(a.length);
}}
case10: class Sample {
int [] a=new int[6];
System.out.println(a); // [I@add34]
System.out.println(a[0]); // 0
System.out.println(a.length); // 6
}}
Once an array object is created its elements will always get default
values.
summarization:
Instance array:
int [] a;
System.out.println(objref.a) //null
System.out.println(objref.a[0]); // null pointer exception
System.out.println(objref.a.length); //null pointer Exception
System.out.println(objref.a) //[I@add234]
System.out.println(objref.a[0]); // 0 default value for int
System.out.println(objref.a.length); //6
Static array:
static int [] a;
System.out.println(objref.a); //null
System.out.println(objref.a[0]); // null pointer exception
System.out.println(objref.a.length); //null pointer Exception
static int [] a=new int[6];
System.out.println(objref.a.length); //6
Local array:
int [] a;
System.out.println(objref.a) //CTE
System.out.println(objref.a[0]); // CTE
System.out.println(objref.a.length); //CTE
System.out.println(objref.a.length); / /6
Coding Standards
Java coding standards:
Sun recommended the following for the naming conventions.
1. In case of classes:
The first letter should be capitalized and if the several words are linked
together to form the name ,the first letter of the inner words should be
upper case.
For the classes the names should be nouns.
Ex: Student, Customer, Employee etc.
2. In case of Interfaces:
For the interfaces the names should be adjective and follows camel
case.
Ex:
Runnable .Serializable,cloneable,Comparable,Movable etc
3.In case of Methods:

The first letter should be lower case and then normal camel case rules
should be used.
The names should be verb –noun pairs
Ex: getBalance(); doCalculation(); setCustomerName();
4.In case of variables:

Like methods the camel case format should be used stating with a
lower case letter.
Ex: buttonwidth; accountBalance; mystring
5.Constants:
java constants are created by marking variables as and final.
They should be named using upper case letter with unscore (_) is the
saperator.
Ex: MIN_HIGHT, MAX_HIGHT
Java Beans Naming Conventions:

Java Beans are java classes that have properties.For every property
there should be getter and setter methods.
All the properties must be declared as the private (to get
security)
For every non – Boolean property will we should have public getXXX()
method.
i.e the getter method is no argument method only.
For the Boolean properties we can have setter method public setXXX()
Arrays Decleration Construction initialization
An array is a data structure that defines an indexed collection of
fixed number of homogeneous data elements. Once the size of
array is fixed there is no chance of increasing or decreasing its
size.Array show wonderful performance when compared with the
collections.
Declaration of array:
Become name is clearly saperated form the type,first one is the highly
recommended way.
At the time of declaration we are not allowed to specify the
size, violation leads to compail time error.
Array Example:int [] a; (valid)

int[6] a; (not valid)
For deceleration of 2/3 dimensional array
int [][] a; (valid)
int [][][]a; (valid)
int a[][]; (valid)
int a[][][]; (valid)
int [] a[][]; (valid)
int [] a[][]; (valid)
int [][]a; (valid)
int [][] a[]; (valid)
int[] a. b[]; (valid)
int[] a,[]b; (not valid)
int a,b[]; (valid)
int [][]a[]; (valid)
Example:
int []a[]; ------>2 di
int []a[];-------->2di
int []a[],b[]; ------->a is 2 di,b is 2 di
int []a[],[]b[]; --------> //not valid
Construction of arrays:
At the time of construction we should specify the size ,other
wise compail time error occures.
i.e int a =new int [6]; (not valid)
int [] a=new int []; (not valid)
int s[]=new int[0]; (valid)
It is legal to have an array with size zero.
Example: int [] a=new int [-6]; (not valid)

We are not allowed to specify the size of the array as nagative
number,violation leads to runtime exception saying negative
array size exception.
char/short /byte/int b=6;
int [] a=new int [b]; (valid)
long/double/float b=6;
int [] a=new int [b]; (not valid)
If we want to specify the size of the array by using some variable ,the
allowed data type for that variable are byte,short,char,int(i.e any data
type which can be implicitly promoted to the int type).
The maximum allowed size for java array is 2147483647.
Once an array is created, all the elements will assign with default
values (depends on data types)
Example:
int [] a=new int [6];
000000
Then a -------------------->For int default 0,for string it is null
int [][] a= new int [3][2];
Then a-----------------------> In java the 2 dimensional array is not
implemented as the matrix.it is simply an array of arrays.
int [][] a= new int [3][];
a[0] =new int[2];
a[1]=new int[3];
a[2]=new int[4];
so,no need to specify the second dimension in 2d,3d arrays.
Array Examples:
int [][] a=new int[3][2]; (valid)
int [][] a=new int[3][]; (valid)
int [][] a=new int[][2]; (not valid)
int [][] a=new int[][]; (not valid)
Base size should be specified mandatory.
int [][][] a new int [2][][]; (valid)

int [][][] a new int [2][3][]; (valid)
int [][][] a new int [][3][4]; (not valid)
Example:
int[] a=new int [6];
System.out.println(a[0]); -----------> output: 0
boolean[] b=new booleab[3];
System.out.println(b[0]); -------------> output: false
String s=new String [6];
System.out.println(s[0]); -------------->output: null
Example:
int [][] a=new int [2][3];
System.out.println(a[0]); -----------> output: Garbage value[I@add234]
System.out.println(a[0][0]); -----------> output: 0
int [][] a=new int [2];
System.out.println(a[0]); -----------> output: null
System.out.println(a[0][0]); -----------> output: Null Pointer Exception
Initializing an array:
a[0]=20;
a[1]=30;
a[2]=40;
a[3]=50 ------> Leads to array index out of bound Exception
If you are accessing an array with invalid index or some -ve index we
will get a RTE saying array out of bound exception.
a[4.0]; ---------> leads to compail time error
Deceleration ,construction and initialization in single line:
int [] a;
a=new int [3];
Example:
char[] ch={‘l’,’a’,’x’,’m’,’a’,’n’};
String [] s= {“laxman”,”scjp”};
int [] a;
a ={10,20,30}; ----------------> Leads to compail time error illegal start
expression
so Declaration,contraction,initialization must in a single Line.
length Vs length():
length:This is a variable.applicable for only for array objects
represents the number of elements or the size of the array.
Ex1:
int a=new int[6];
System.out.println(a.length); ------------------> output: 6
Can’t apply to String
Ex2:
String s=”Laxman”;
System.out.println(s.length);
Given CTE because length variable applicable only for array objects.
length(): It is a final method applicable for string objects.
It represents the number of characters present in the String Object.
Ex:
String s=”Laxman”;
System.out.println(s.length()); ---------> 4
System.out.println(s.length); ---------->error
Anonymous Arrays: There are name less arrays.
Purpose of these anonymous arrays is just for instant use.
Example:
class Sample {
System.out.println(sum(new int[]{10,20,30}));
}}
output: 60
While constructing anonymous arrays we are not allowed to
specify the size .violation leads to compile time error.
If we want, we can assign anonymous array for any reference
variable.
i.e int [] a=new int[] {10,20,30,40}; ----------> valid
Array Element Assignments:

As array elements we can take any values which can be implicitly
promoted to declared type.
int[] a =new int{3};
a[0]=10; -------> valid
a[0]=’a’; -------->valid because char can be implicitly promoted to int
type.
a[0]=b; ---------->valid because byte can implicitly promoted to int
type.
a[0]=10l; --------->CTE because long can’t be implicitly promoted to int
Here we can give only String objects.
Object[] o=new Object[b];
If an array is declared as object reference array we are allowed to
assign the objects of either declared type or its child classes.
Array variable Assignments:
Case 1: int [] a={10,20,30};
char [] ch={‘a’,’b’,’c’};
int [] b=ch; -------------->CTE Incompatible types reqired:int[]
found:char[]
A char element can be assigned in the place of int element .But we are
not allowed to give a char array in the place of int array.
But int [] b=a; ---------> valid
Case 2: int [] a={10,20,30,40};
int [] b={50,60,70};
In this case a=b and b=a, both are valid because while assigning one
array to another we have to consider only types irrespective of sizes.
Char ch={‘a’,’b’,’c’,’d’};
a=ch; --------->Incompatable not valid
case 3: int [][] a=new int[2][3];
a[0]=new int [6]; -------> valid
But a[0]=new int [2][3] -------> not valid
Int [][] a=new int[2][];
a[0]=new int[6]; -------> valid
a[0]=10; --------->CTE incompatable types reqired : int[] found : int
a[0]=new int [2][3]; -----------> CTE incompatable types reqired : int[]
found : int[][]
case 4: int [] a=new int[6];
System.out.println(a.length); -------------> 6
Int [][] a=new int [3][4];
System.out.println(a.length); -------------> 3
System.out.println(a[0].length); -----------> 4
Java operators
Operators&Assignments:
• increment/decrement
• shift
• arithmetic
• equality(==,!=)
• relational
• bit-wise
• short-circuit
• instanceof
• cast
• conditional(?)
• new
• []
Increment& decrement operators:

• Post Increment ------> y=x++;
• Pre Increment ------> y=++x;
• Post Decrement ------> y=x--;
• Pre Decrement ------> y=--x;
Example: int x=4;

int y=x++;
System.out.println(y); //4 .unexpecompile time errord type.
System.out.println(x); //5
Example: int y=++4;

System.out.println(y); //Compile time error
Increment or decrement operators, we can apply only for
variables not for constant expressions. Violation leads to
Compile time error saying unexpecompile time errord type
Required: variable but found=value.
Ex: int x=4;
int y=++(++x);
System.out.println(y); //COMPILE TIME ERROR
we can apply increment/decrement operators for variables only
one time. Ie . nesting of increment/decrement operators are
not allowed.
Ex: int x=y;
final int x=y;
x++;--- [x=x+1] x++;
System.out.println(x); //5
System.out.println(x); //COMPILE TIME ERROR
Increment/decrement operators, we can’t apply for the final
variables. Violation leads to compile time error saying can’t assign
values to final.
Ex: double d=10.5;
d++; System.out.println (d); //1.5
Increment/decrement operators, we can apply for floating point data
types.
Ex: byte b=10;
b=b+1;
System.out.println (b); //compile time error
Possible loss of precession
found: int , required :byte
Ex: byte b=10;
b=b++;
System.out.println (b); //11
i.e automatic typecasting takes place internaly
Ex: byte a=10;

byte b=20;
byte c=a+b;
System.out.println (c); //compile time error
if we can perform any arithmetic operation between any 2 variables a
and b the result is always max (int, type a, type b )
byte + short=int
char + char=int
int + char=int
int + long=long
doubles + byte=double
Arithmetic OPERATORS:-( + , - , * , / , % )
byte a=10
byte b=20
byte c=a+b; //compile time error plp req:byte
If we can perform arithmetic operators b/w any two operands a and b ,
the result type is, max(int, type a, type b)
Ex: int a=10+’a’ => 10+97=107
double b=10+12.5 => 10.0+12.5=>22.5;
For representing infinity, there are no constant; define in the integer
class. Hence 0/0 results is sum time exception saying arithmetic
exception
System.out.println(10/0); //Runtime Exception by zero .
System.out.println(10.0/0); //infinity
System.out.println(10.0f/0); //infinity
But in the float and double classes for representing infinity constants
are defined.
System.out.println (Float. POSITIVE_INFINITY); // infinity
System.out.println( Float NEGATIVE_ INFINITY); //-infinity
final float postive_ infinity ,

final float negative _ infinity are the constants contain in float class.
0/0 is undefined in the Integer class for representing undefined results
there is no constant available . Hence 0/0 results arithmetic exception.
0/0 → arithemetic exception but in float and double classes for
representing
undefined values there is a commands available. public static final
float NaN.
NaN→not a number and public static final double NaN
Ex:System.out.println(0.0 / 0) → NaN
System.out.println(Math.sqrt(4)); → 2.0
System.out.println(Math. Sqrt(-4)); → NaN.
System.out.println(10/0)→ Arithmatic exception
System.out.println(10.0 / 0)→ infinity
System.out.println(-10.0 /0→ - infinitz
System.out.println(0/0) → Arithematic Exception.
System.out.println(0.0/0 → NaN
System.out.println(-10/0) → arithmatic exception
System.out.println(-10.0/0)→ -infinity,
System.out.println(-0.0/0)→ NaN.
Float. POSITIVE_INFINITY = = Float. POSITIVE_INFINITY; // true
Float . POSITIVE_INFINITY = =Double. POSITIVE_INFINITY. // true
Float . NaN = =Float. NaN.
Float. NaN >double. NaN }false
Float. NaN !=Float. NaN →true.
if one are comparing NaN with any other , including NaN itself, the
result is always false, except for not equal(!=)operator.
Arithmetic exception:
1. runtime exception (unchecked)
2. only in the cone of integer arithmetic.
3. / and % only there two operators result in Arithmetic exception.
String concatenation operation:-
‘+’ is the only operator in java which in overloaded. We can one for
arithmetic addition and for string concatenation.
String a=”java”.
int b=30;
int c=20;
int d=10;
System.out.println (a+b+c+d);→java302010;
System.out.println(b+a+c+d);→ 30java2010
System.out.println(b+c+d+a); →60java
System.out.println(b+c+a+d);→50java10.
* If at least one operand is of string type then + acts as string

concatenation operator other wise + acts as arithematic operator.
SHIFT OPERATORS (1.4 ONLY):-

Left shift (<<)
Right shift ( >>)
Unsigned /zero filling right shift operator ( >>>)
In order to get high resolution of pictures
For compression of data also used these shift operators frequently use
in j2me edition.
Left Shift Operator:
a << b shift the bits of a ,b times to the left hand side.
Ex: 8 << 33 then 8 << 33 % 32 = 8 << 1 // result=16
Ex: 8 << - 31 then 8 << -31+32 = 8 << 1 // result= 16
Right Shift Operator:

a>>b shift the bits of a ,b times to the right hand side by filling the left
hand side bits with sign bit.
8 >> 1 --> 0000 …….100 = 4.
Filled with sign bit zero.
a >> b =a/2 power b for 8 >> 1 =8/2 power 1 =8/2=4.
If b < 31 then b=b+32
If b >31 then b= b% 32.
- 8 >> 1 ---> -8/2 power 1 = -8/2= -4.
Unsigned Right Shift Operator:

a>>> b , shift the bits of a, b times to the right hand side. By filling left
most bits with zero always.If a is +ve ,then there is no difference
between right shift and unsigned right shift operator.Except shift
distance zero ,the result of unsigned right shift operator is
always positive.
I few are applying shift operator between a and b the result type is
always max(int type of a)
Case1: byte b=8 >>1; // valid

Case2: int a=8;
byte b=a >> 1; // invalid
Case3: final int a=8;
byte b=a>>1; // valid
Case 4:long c=1;
byte b=8>>c; //invalid (as per max(int,type of a)
In a << ,>> ,>>> b ,If a and b ,both are compile time constants then
the compiler won’t go for formula for the result type.If at least one in
the variable ,either a or b then the compiler checks the type of the
result which is max(int,type of a) , the type b never participated in the
result .
Access modifiers
class Modifiers:
Once we are writing a class the access modifier describes the
properties of that class .(creation of child class is allowed or not
,creation of object is allowed or not ,we can access this class from
outside the package or not and so on).
Access specifiers or Access modifiers are same in case of java.java
compiler shows the error related to public,static,.......so on , it use the
word modifier not Specifier.
The allowed modifiers for the Top level classes are:
1.public 2.default 3. final 4.abstract 5. strictfp
If we are using other then these modifiers ,compile time error
saying modifier some not allowed here.
For the inner classes the following are allowed modifiers:
1.public 2. private 3.protected 4.default 5.final 6.abstract
7.static 8.strictfp
public class:
A public class can be accessed from any where with in the package
/outside the package.
package pack1;
public class B
{
System.out.println(“hai”);
}
package pack2
{
import pack1.B;
class A
{
public static void main(String arg[])
{
B b=new B(); // we can access
}
class:
If a class declared as the default ,we are allowed to access that class
only with in the current package.If you are trying to access from
outside package compilation fails.
package pack1;
class B
{
}
package pack2
{
import pack1.B;
class A
{
{
B b=new B(); //we can't access
}
Here class B is is default ,but not public in pack1.So this class can’t be
accessed from outside package.
final class:
If a class declared as the final then we are not allowed to
create the child class.
Advantage: We can implement security.
Limitation: As we are not allowed to create the child class,we are
missing the key benefits of object oriented programming ,re usability
and flexibility.Its not a good programming practice to use final classes
in the real time unless security is required.
final method:
If a method declared as the final ,it indicates that this
implementation is final implementation.
ie. we are not allowed to override this implementation the
child class.
Observations:
If a class declared as the abstract, we should create the child class to
provide implementation for abstract methods.
If a class declared as the final, you are not allowed to create the child
class.Hence final and abstract combination is illegal for classes.
Example:
class Sample
{
void m1(); //error: missing method body or declaration missing.
{
}
}
Abstract methods should be overridden in the child class to provide
implementation.But final methods are not allowed to override. Hence
abstract and final combination is illegal for methods also.
A final class never allowed to contain abstract methods. But a final
methods is allowed to keep inside abstract class.i,e final method in
abstract class is valid But abstract method in final class is not
valid.
Abstract is the keyword which can be applied for classes and methods
only.i.e we can’t use abstract keyword for a variable.
final is the keyword which can be applied for classes ,methods and
variables.
Strictfp: Strict floating point

This keyword we can apply for classes and methods .i.e we
can’t apply strictfp for the variables.
If a method declared as the strictfp all the floating point
calculations inside that method has to follow “IEEE 754”
standards so that we will get platform independent result.
If a class declared as the strictfp, all concrete methods in that
class has to follow IEE 754 standard for floating point
calculations.
Abstract and strictfp combination is not-valid for methods .But
it is valid combination for the classes.
Not-valid combinations
abstract and final .
abstract and strictfp
abstract and synchronized
abstract and static
abstract and native
abstract and private.
Method level Modifiers and Variable level Modifiers:
public members:
If a member is declared as public ,we are allowed to access that
member from any where with in the package or outside the package.
package pack1;
class A
{
public void m1()
{
System.out.println(“hai”):
}
}
package pack2;
import pack1.A;
class B
{
{
A a=new A(); //error
a.m1();
}
}
The corresponding class must be visible.Before checking member
visibility, first we have to check class visibility.
If class A is declared as public then the class B compiles fine and prints
“Hai”. Default member:
If a member declared as the default ,that member is visible with in the
current package only.
package pack1;
public class A
{
void m1()
{
System.out.println(“hai”):
}
}
package pack2;
import pack1.A;
class B
{
{
A a=new A();
a.m1(); //error
}
}
error:m1() is not public in pack1.A.
Hence default modifier is also known as package level
modifier.
private members:
If a member declared as the private we can access with in that class
only.i.e from outside the class, you are not allowed to access.
It is highly recommended to declare data members as private to
achieve security.
protected member:The most misunderstood modifier in java .If a
member declared as the protected with in the current package,every
where we are allowed to access,but outside the package ,we can
access only in the child classes.
protected= + child classes;
Example:
package pack1;
public class A
{
protected void m1()
{
}
}
case 1:
class B
{
{
A a=new A();
a.m1(); // hai
}
}
Case 2:
class B extends A
{
{
B b=new B();
b.m1(); // hai
}
}
case 3:
A a1=new B();
a1.m1(); //hai
case 4:
B a=new A();
a.m1(); // error
Example:
package pack2;
import pack1.A;
class B extends A
{
{
A a=new A();
a.m1();
}
case 2:
B b=new B();
b.m1(); // valid
case 3:
a a1=new B();
a1.m1(); // in-valid
conclusions:
The protected members can be accessed with in the current package
any where either by using parent class reference or by using child
class reference.
But from outside package we can access protected member only by
using child class reference.
If we are using parent class reference to access protected member
from outside package we will get a compile time error.
Example:
case 1:
class Sample
{
{
Object o=new Object();
o.finalize(); // error
}
}
error :finalize has protected access.
Case 2:
public static void main(String arg[])throws Throwable
{
o.finalize(); // valid
}
case 3:
Object o=new Sample();
o.finalize(); //in valid
final variables:
final is the keyword which can be applied for methods classes
and variables.
Instance and static variables will get default values always
.There is no need to perform explicit initialization.
But the local variables never get any default values .Before accessing a
local variable ,we should perform initialization other wise compile time
error.
final instance variables :
For the final instance variables,we should perform initialization
other wise compile time error.
The final instance variable must be initialization before constructor
compiles. i.e at the time of declaration or inside instance initialization
block or inside constructor.
Example:
final int i;
{
Sample s=new Sample()
System.out.println(s.i); // invalid
}
final-static variables:-
Final static variables must be initialized before class loaded
into memory. Otherwise compile time error. i.e we can perform
initialization for the final static variables at one of the
following places.
1. at the time of declaration
2. Inside the static initialization block
final static int I;
static
{
int i=30;
}
final-local variables:-
Local variables even though we can declared as the final must be
initialized before using.
class Sample
{
Public static void main(String args[])
{
final int I;
} // hai
For the local variables the only allowed modifier is final.
Example:
class test
{
{
final int a; //instead of final we cant write int modifier
System.out.println(“hi”);
}
}
The variables which are declared as the method arguments are simply
acts as local variables of that method .hence the only applicable
modifier for the logical variables is final. If any formal parameter
declared as the final we are not allowed change its value with in the
method.
Example:
class test
{
{
m1(100,200);
}
}
public static void m1(final int i, final int j)
{
i=200; //error
i=300; //error
}
}
Static Modifier:
The keyword static can be use for classes, methods, variables
We can not apply static keyword for the top level classes, but
we can apply inner classes.
For every object a separate copy of instance variables will be created
but in the case of static variables a single copy will be created at the
class level and shared by all the objects of that class.
Example:
class test
{
int i=10;
static int j=20;
public static void main(string arg[])
{
Test t1=new Test();
t1.i=100;
t1.j=200;
System.out.println(t1.i+’…”+t1.j); //100,200
Test t2=new Test();
System.out.println(t2.i+’…”+t2.j); // 10,200
t2.j=2000;
System.out.println(t1.i+’…”+t1.j); //100,2000
}
}
Most of the cases the keyword static associated with final modifier for
defining class level constants.
Non static variables can not be returning form static modifier/ content:
class test
{
int i=10;
{
System.out.println(i);
}
}
error: Non static variable I cant be returning static content
example:
1) int i=10;
2) static int i=10;
3)public void m1()
{
}
4) public static void m1()
{
}
Which of the following are not allowed simultaneously in the same
class
1) & 3) instance variable can't be accessed from instance area,either
instance block, constructors or instance access block
1) & 2) compile time error.. non static variables are instance variables
can not be referenced from static constant
2) & 3) , 2) & 4)… static variables can be accessed from any where
either from instance area or static area
3)Usually static methods are utility methods and we should provide

complete implementation but for abstract methods we are not allowed
to provide implementation . Hence abstract and static
combination is illegal for the methods.
4) we can overload static methods.but we can not override
Synchronized Keyword:
Synchronized is the keyword which can be apply for method
and blocks. i.e we can not apply synchronized keyword for
classes and variables.
If a method declared as synchronized at a time only one thread
is allowed to execute that method on the given object.
Advantages:
1) We can provide thread safety
2) We can avoid data inconsistency problems
Disadvantages:
1)synchronized keyword increases waiting time of threads and hence
performance of the system goes down.hence unless and until there is
no specific requirement do not use synchronized keyword in the
coding.
Note: Synchronized is the keyword which is always talks about
implementation but abstract never talks about implementation.Hence
synchronized and abstract combination is illegal for the
methods.
Native Modifier:
Native is the keyword which can be apply only for methods. i.e
we can not apply native keyword for classes and variables.
1) A native method means. The method which is implemented in non-
java like c,c++;
2) Native methods are also known as foreign methods.
Advantages of Native method:
1) As the performance of java is low for improving the performance we
can depends on c or c++. This stage methods can be helped by native
keywords
2) We can communicate legacy systems by using native keyword
Demo:
class NativeEx
{
static
{
System.loadLibraries(“path of native methods library”);
}
native void m1();
}
class Client
{
{
Native n=new NativeEx();
n.m1();
}
}
For the native methods already implementation is available but
abstract method means implementation is not available .hence
abstract and native combination is illegal for the methods
Native methods already implementation is available we are not
providing any implementation. Hence nativemethod declaration
should be ends with semicolon
Native and strictfp combination is illegal for methods because
old languages may not fallow IEEE 754 standerd for floating
point.
We can override a native method
We can overload a native method
Transient Keyword:
Transient is the keyword which can be applicable only for
variables i.e., we are not allowed to use transient keyword for
methods and classes.
Serialization:
The process of saving an object to a file is called serialization Strictly
serialization means “The process of converting java supported
format object to network supported format object (or) file
supported format object is called serialization.”
1) If a variable declared as a transient, at the time of
serialization JVM ignores the values of that the transient
variable. Instead of original values JVM saves default value.
2) Hence transient means not to serialize.
Example:- While saving account information permanently to a file we
are not allowed to save passwords for security reasons such type of
variables we have to declare by transient keyword
3)We can serialize only serializable objects violation leads to runtime
exception saying not serializable exception
4)An object is said to be serializable if an only if the corresponding
class implements serializable interface
Transient Example:
import java.io.*;
class TransientDemo implements Serializable
{
int i=10;
int j-20;
public static void main(string args[])throws exception
{
TransientDemo t1=new TransientDemo();
System.out.println(t1.i+”----“+t1.j);
file output stream fos=new file output stream(“abc.txt”);
object output stream oos=new object output stream(fos);
oos.writeobject(t1);
//t1.i=1000
//t1.j=2000
FileInputStream fis=new FileInputStream(“abc.txt”);
ObjectInputStream fis=new ObjectInputStream(fis);
Transient Demo t2=( Transient Demo)ois.writeObject(t1);
System.out.println(“t2.i+”…”+t2.j);
1).If we are not declaring implements serializable we will get a runtime
exception not serializable exception
2)if we are not keeping throws exception compile time error saying
unreported exception must be called or declared to be thrown
Note:- static variables never part of object state hence we are

not participating in the serialization process during a static
variables as the transient is useless and there is no impact.
Volatile
Volatile is the keyword which can be applicable only for
variables i.e we can not use for classes and methods. If the value of
the variable is changing frequently such tpe of variables we have to
declare with this volatile keyword.
1) For the volatile variables JVM will create a separate private
copy for every thread.After completing entire transaction but
that thread the final value will be updated in the master copy.
So that the value of the volatile variable is always stable
2) At variable level we can achieve synchronization by using volatile
keyword
3) For every thread maintaining a separate copy is always difficult
.hence performance of the system goes down
4) Volatile means the value keep on changing but final means the
value is not allowed to change. Hence volatile and final
combination is always illegal. We are not declaring a final variable
as volatile.
class:
In object-oriented programming, a class is a programming
language construct that is used as a blueprint to create
objects. This blueprint includes attributes and methods that the
created objects all share.
Usually, a class represents a person, place, or thing - it is an
abstraction of a concept within a computer program. Fundamentally, it
encapsulates the state and behavior of that which it conceptually
represents. It encapsulates state through data placeholders called
member variables; it encapsulates behavior through reusable code
called methods.
More technically, a class is a cohesive package that consists of a
particular kind of meta data. It describes the rules by which objects
behave; these objects are referred to as instances of that class. A class
has both an interface and a structure. The interface describes how the
class and its instances can be interacted with via methods, while the
structure describes how the data is partitioned into attributes within an
instance. A class may also have a representation (meta object) at run
time, which provides run time support for manipulating the class-
related meta data. In object-oriented design, a class is the most
specific type of an object in relation to a specific layer.
Programming languages that support classes all subtly differ in their
support for various class-related features. Most support various forms
of class inheritance. Many languages also support features providing
encapsulation, such as access specifiers.
class Example:
Class java
{
properties(variables);
Actions(methods);
}
object:
In its simplest embodiment, an object is an allocated region of
storage. Since programming languages use variables to access
objects, the terms object and variable are often used interchangeably.
However, until memory is allocated, an object does not exist.
Any language present objects and this should not be confounded with
the most powerful concept of object-orientation.
In procedural programming, an object may contain data or instructions,

but not both. (Instructions may take the form of a procedure or
function.) In object oriented programming, an object may be
associated with both the data and the instructions that operate on that
data.
How an object is created depends on the language. In a prototype-

based language (e.g.,JavaScript) an object can be created from
nothing, or can be based on an existing object. In a class-based
language (e.g- ,Java), an object is created as an instance (or
instantiation) of a class. The class forms a specification for the object.
To give a real world analogy, a house is constructed according to a

specification. Here, the specification is a blueprint that represents a
class, and the constructed house represents the object.
Object example:
class Sam
{
int i=10;
void mone()
{
System.out.println("java");
}
{
Sam s=new Sam(); //Here is the Object
}}}
Abstraction
Hiding internal implementation is called Abstraction.
Advantages:
Security
Enhancement easy
we can enhance the internal implementation with out effecting outside
world.
Encapsulation
Encapsulation Advantages:
Security
Easy to enhance
Maintainability
Modularity
Example:
class Sample
{
public int i=10;
public int getId()
{
return i;
}
public void setId(int x)
{
this.i=x;
}
}
The major limitations od encapsulation is,it increases the code
(because we have to getter and setter methods for the data variables)
and hence slows down the execution.
Tightly encapsulated class:

A class is said to be tightly encapsulated if and only if data
members as the private
Check whether the fallowing classes are tightly encapsulated or not.
a)
class A {
private int x=10;
public void setX(int x)
{
this.x=x;
}
public int getX()
{
return x;
} ------------------//tightly encapsulated
b). class A{ private int y=10;} -----//tightly encapsulated
c). class A{ private int x=20;} ----// A is tightly encapsulated, B is not

class B extends A{ private int y=30;}
d). class A{ int y=20;}

class B extends A{ private int z=40;}
class C extends B { private int l=50; }
• If the parent class is not tightly encapsulated no child class is

tightly encapsulated.
Java Inheritance
IS-A relation:
• Also known as Inheritance
• By using extends keyword we can implement IS-A relationship.
• Re usability is the benefit of IS-A relationship
Inheritance is accepted up to certain level but after reaching problems.
Because for every child class object, internally all the parent objects
will be created in the inheritance tree.
In the real time it is recommended to have inheritance up to 8
to 10 levels only. Beyond that it is not suggestible.
is a relation Example:
class Superclass
{
void display()
{
System.out.println("Hi");
}
}
class InheritanceExample extends Superclass
{
{
InheritanceExample ie=new InheritanceExample();
ie.display();
}
}
HAS-A relation:
• Also known as composition or Aggregation.
• By using new operator we can implement HAS-A relationship.
• Reusability (CBM->Component Based Model) is the benefit of HAS–A
relationship.
• The limitation of HAS-A relation ship is, we are increasing the
dependency between the classes. As a result, the maintenance of the
code becomes complex or costly.
has a relation Example:
class Car
{
Engine e= new Engine();
. …….
.......
}
class Engine
{
m1(){}
m2(){}
}
Car class has Engine reference. Hence Car allowed using all the
features of engine. But without Engine object we can’t create Car
object.
Method Signature
Method Signature :
Example:
public void m1(int a, int b)
{
m1(int,int); -----> signature of method m1
}
Example:
public void m1(int a, float b)
{
m1(int , float); //valid
m1(float , int);//invalid
}
• In java the method signature is compiled with method name and

argument list (the order of arguments also important).
• Return type is not part of the signature.
• Compiler uses the method signature to resolve method calls.
• With in a class two methods having same the signature is not
allowed, violation needs to CTE saying method is already
defined in class.
Example:
class Test
{
public int m1(int i){}//invalid, CTE: m1(int) is already defined in test
public void m1(int i){}
}
Method Overloading
Two methods having the same name are not allowed in the case of C-
language, for every data type even though the functionality in the
same; we should maintain different method names. It increases the
complexity of the programming. But in java, two methods having the
same name is allowed irrespective of parameters. We can maintain the
same method name for similar type of functionality. It simplifies the
programming. Such types of methods are called Overloaded methods.
• Two methods are said to be overloaded if and only of they
have the same method name, but different parameter list (at
least order).
• The signatures of the two overloaded methods must be different.
Example:
public void m1(){}
private int m1(int i){}
• Here m1() & m1(int i) are overloaded. We never consider return type,
access modifier and throws class in overloading.
Example:
class Sample
{
public void m1()
{
System.out.println(“no arg”);
}
public void m1(int i)
{
System.out.println(“ int arg”);
}
public void m1(double d)
{
System.out.println(“ double arg”);
}
public static void main(String a[])
{
s.m1();
s.m1(10);
s.m1(10.5);
}
}
• In the case of overloading which overloaded method must be

executed is decided method must be executed is decided by compiler
only based on reference type.
• Ie., Overloaded method resolution is the duty of compiler only. Hence
Overloading is the best
ex. of static polymorphism and some times also known as Early
Binding.
s.m1(10L);//double arg
s.m1(‘a’);//int arg
i.e., Automatic Promotion in Overloading:

• If we are calling a method m1() by passing char as arg on the sample
reference then the compiler will check in the Sample class for m1(),
which can take char as the arg.
• If it finds that method, it will execute at run time.If there is no such
method the compile promotes that char arg to the int arg and checks
for m1(int) method.
• If there is no such method, the compiler will check for m1(long),
fallowed by m1(float),fallowed by m1(double). Still if the compiler
won’t find any such method then only compiler will raised CTE saying
‘cannot resolve the symbol m1(char).
CASE 1:
class Sample
{
public void m1(int i,float f)
{
System.out.println(“int,float”);
}
public void m1(float i,int f)
{
System.out.println(“float,int”);
}
{
s.m1(10,10.0f);//int,float
s.m1(10.0f,10);//float,int
s.m1(10,10);//invalid-> CTE:reference m1 is ambiguous
}
}
CASE 2:
class Sample
{
public void m1(String s)
{
System.out.println(“String version”);
}
public void m1(Object o)

{
System.out.println(“Object version”);
}
public void m1(double d)
{
System.out.println(“double version”);
}
{
s.m1(“viswan”);// String version
s.m1(new Object());// Object version
s.m1(null);// String version
}
}
If there is Double (wrapper class) then CTE: reference to m1 is
ambiguous.
CASE 3:
class Animal
{
}
class Monkey extends Animal
{
}
public class OLStaticBinding {
public void m1(Animal a)

{
System.out.println("Animal version");
}
public void m1(Monkey m)
{
System.out.println("Monkey version");
}
{
OLStaticBinding s=new OLStaticBinding();
Animal a1 =new Animal();
s.m1(a1); // Animal version
Monkey m =new Monkey();
s.m1(m); // Monkey version
Animal a2 =new Monkey();
s.m1(a2); // Animal version
}
}
}
In the case of overloading the method resolution performed by the
compiler is based on the reference type.
Method Overriding
If you don’t want parent class implementation for any method we can
override in the child class based on our child class requirement. This
concept is called Overriding.
While overriding we have to fallow rules:
1. In the overriding, the method names and arg’s must be
same.
Ie. In the case of the overriding the signatures of the methods
must be same Until 1.4 version, the return types must be
same. But from 1.5 version onwards covariant return types are
also allowed.
Example:
class p { public Number getNumber(){} }
class c extends P{ public Number getNumber(){} }
(or)
class C extends P
{
public Byte/Short/Integer getNumber(){}
}
For Number class Byte/Short/Integer is co-variant return types or
classes.
Hence in case of overriding as the return type we can keep child class
objects also.
Example:
import java.io.*;
class P
{
public object m1(){ return new object; }
}
class C extends P
{
public Object m1(){ return new Object; }
}
class C extends P
{
public String m1(){ return “durga”; }
}//in 1.4 CTE saying m1() in C cannot override found:string, req:object:
in 1.5 ver no CTE
2. final methods can’t be overridden.
3. private methods never participate in the in the overriding
because these methods are not visible in the child classes.
4. While overriding decreasing access specifier is not allowed.
Violation leads to CTE.
class P { public int m1(){} }
class C extends P { public int m1(){} }
Parent class -------------------------------- Child class
public ----------------------------------------------- public
protected ---------------------------------------- protected, public
default ---------------------------------------- default, protected ,public
private ---------------------------------------- private, default, protected, public
* While implementing any interface method, we should declare that

method as public in the implemented class.(by default implements
interface method is public and abstract)
* An abstract method can be overridden as abstract. The child of the
original child class is responsible for the implementation.
class P{
public void m1()
{ } }//non abstract
abstract class C extends P{
public abstract m1(); }//valid abstract
5. While overriding the size of the CheckedException should not

increase. There is no rule for UnCheckedExceptions.
Example: Base or parent class :
public void m1()throws IOException
Derived or child class :
public void m1()throws FileNotfoundException //valid
public void m1()throws Exception -->CTE
public void m1()throws RunTimeException //valid

We can override a synchronized method to non-synchronized
and vice versa we can override native to native to non native
and vice versa.
We can override a non-final method to final method.
We can’t override a static method to non static and a non-
static method to static violation leads to CTE .
While overriding method has to execute will be decided by JVM based
on the Run Time Object. Hence Overriding is an example of
“dynamic polymorphism” or “LateBinding” (Dynamic Method
dispatch).
If the parent’s class reference can be used to hold child class object by
using that reference we are allowed to call only parent class methods.
Child class specific methods are not allowed to call by using parent
class reference.
Method Hiding:-
This is exactly same as overriding except both parent & child class
methods must be declared as static. In the method hiding the method
resolution take care by compiler only based on the reference type.
Ex:
class P
{
static int x=10;
int y=20;
}
class C extends P
{
static int x=100;
int y=200;
}
class Sample
{
public static void main(String[] a)
{
P p=new C();
System.out.println(p.x+”,”+p.y); //10,20
C c=new C();
System.out.println(c.x+”,”+c.y); //100,200
P p1=new P();
System.out.println(p1.x+”,”+p1.y); //10,20
}
}
We can’t override in the child class. But if define exactly same variable
in child class.
Variable resolutions take care by compiler only based on the reference
type.
Constructors
The purpose of Constructor is to perform of our creted object.
Whenever we are calling new operator for the creation of object, it
calls constructor automatically to provide initialization for the
object.
class Student
{
String name; int rno;
Student(String name, int rno) ----> Constructor
{
this.name=name;
this.rno=rno;
}
{
Student s=new Student(“xxx”,101);
Student s1=new Student(“yyy”,102);
-------
------
}
}
Rules Of Constructor :
1. Constructor concept is applicable for every class including
abstract class also.
2. Interface doesn’t have Constructor’s concept.
3. The name of the constructor and the name of the class must be
same.
4. The allowed modifiers for the constructors are public,
private, protected, and default. If you are applying any other we
will get a CTE saying “modifier xxx not allowed her”.
5. We can’t give return type for the constructor even void also.
If we will give return type for the constructor that thing as a method
instead of constructor that thing as a method instead of constructor
(so, there is no CTE). Ie., it is legal (but stupid) to have a method
whose name same as classname.
Default Constructor:-
If the programmer is not writing any constructor, then only compiler
will generate a default constructor.
Ie., either programmer written constructor or compiler generated must
present in your class but not both at a time.
Prototype of default constructor shown below:
a).Programmer written code:- class Test{}
Compiler generated code:-
class Test
{
Test()
{
super();
}
}
The default constructor is always no argument constructor.
The access modifier of the default constructor is same as access
modifier of the class (public & default only).
The default constructor contains only one statement which is ‘no arg
call to super class Constructor ‘ (super();)
b) Programmer written code:-
class Test {
Test(int i)
{
System.out.println(“constructor”);
}}
class Test {
Test(int i)
{
super();
}}
c). Programmer written code:-

class Test {
Test(int i)
{
super();
System.out.println(“Hai”);
}}
Compiler generated code:- no new code is going to generate.
d). Programmer written code:-

class Test {
void Test()
{
System.out.println(“hello”);
}
}
class Test {
void Test()
{
}
Test()
{
super();
}}
e). Programmer written code:-
class Test {
Test()
{
this(10);
}
Test(int i)
{
}}
class Test {
Test() {
this(10);
}
Test(int i) {
super();
}}
The first line inside a constructor must be a call to super class
constructor (by using super();) or a call to overload constructor
of the same class. ( by using ‘this’ keyword ).
If you are not writing the first line as either ‘super()’ or ‘this’
then compiler will always keep a no arg call to super class
constructor (super();).
1. Allowed only in Constructors.
2. Must be first statements.
3. Either super() or this, but not both.
We can invoke another constructor from constructor from a method
violation leads to CTE. i.e, super() or this must be used inside the
constructor only not anywhere else.
Overloaded Constructors:
We are allowed to keep more than one constructor inside a class ,
which are considered as overloaded constructors. We can’t override
the constructors, because they belong to the same Ex: class Test {
Test(int i){}
Test(){} ---->Overloaded Constructors
}
Constructors are not inherited and hence we are not allowed to
override a constructor.
while recursive method invocation we will get stackoverflowException
But in case of constructors we will get compile time error.
If we are writing any constructor in our class it is recommended to
place default constructor also. Otherwise we should take care while
writing the constructor child case.
If the parent class constructor throws some Checked Exception, while
writing child class constructors we should take care.In case of
unchecked exception no rule.
Recursive Constructor invocation:
class Sample {
Sample() // This is a compile time problem
{
this(10);
}
Sample(int i)
{
this(); // Invalid, CTE: recursive constructor invocation
}
{
}
}
Constructing the Child class constructors:
Example:
class P {
P()
{ super(); }
}
class C extends P
{
C() {
super();
} } //valid
Example:
class P {
P(int i)
{
}
}
class C extends P
{
C()
{
super(10); // valid (without super invalid)
}
}
Example: class P
{
P() throws Exception ----> checked exception
{}
}
class C extends P
{
C() // compile time error unhandled exception type exception
{}
}
Date 3/11/2010.
abstract class
We can apply abstract keyword for the classes and methods .abstract
keyword is not possible for variables.If method declared as
abstract we don’t know implementation child class is responsible to
provide the implementation for the parent class abstract methods.
Abstract public void m1(); // here ; is mandatory.
Abstract method has declaration only and should not have any
implementation.
This is the way of decorating abstract method .we should not keep
curly braces at end.
If a class contain at least one abstract method we should have to
declare that class as abstract other wise compile time error.
An abstract class is not compulsory to have an abstract method.i.e
abstract class may contain zero number of abstract methods
also.this is for restricting object creation.
HttpServlet class doesn’t contain any abstract methods ,still the class
is declared as abstract because the methods present in HttpServlet
can’t provide any request ,response for the end user ,these methods
are just for sending error information.
It’s a good programming practice to use abstract methods ,abstract
classes and interfaces.
Example:
class Sam
{
abstract void m1(); //error
}
Example 2:
abstract class Xy
{
abstract void m1(); // valid
}
Example 3:
abstract class X
{
void m1() // valid
{
System.out.println(“valid”);
}
}
Example 4:
abstract class X
{
abstract void m2();
}
class Y extends X // error we must provide the implementation for m2

method .
{
}
interface
An interface defines the contract between service provider and the
client without highlighting internal implementation.
i.e Interface describes the services ,what service provider provides and
what client get.
The main advantage of interface are :
1. we never high lite our implementation to the outside world,we can
achieve security for our implementation.
2. With out effecting outside world,we can enhance our internal
implementation. Interface is considered as 100% pure abstract class
because we never keep implementation inside interface. And hence
all the methods present inside an interface are abstract
methods.
For the service provider point of view an interface defines the services
provided by that person.
From the client point of view an interface describes what services he
required.
Declaring an interface:
interface Interf
{
public void m1();
public void m2();
}
class Bea implements Interf
{
public void m1()
{
System.out.println(“implementation m1”);
}
public void m2()
{
System.out.println(“implementation m2”);
}
{
Interf i=new Interf();
i.m1();
}
}
If you want to provide implementation for any interface
method, it must be declared as public .
The first concrete class which implements an interface must provide
implementation for all the interface methods other wise the class must
declared as abstract.
We can declare an interface (top level) with <default> and
public,abstract,strictfp modifiers.
interface methods Declarations:
All the interface methods by default abstract and public (either
we are specify or not specify) not concrete method.
Examples:
Void m1();
public void m1();
abstract void m1();
public abstract void m1();
All the above are same .
Hence the above four methods declaration are identical.
An interface method never be declared as native ,strictfp,private
,static, synchronized and protected.
interface variables Declarations:

All the interface variable are by default public ,static and final.
Hence the following variable declaration inside an interface are
identical.
interface interf
{
int x=10;
public int x=10;
public static final int x=10;
final int x=10;
static int x=0;
}
Hence an interface we never declared as private ,protected and
transient.
All the interface variables must perform initialization at the

time of declaration.
Hence the following code will not compile.
interface Interf
{
int x;
}
Inside implement classes we are not allowed to change the value of
interface variable violation leads to compile time error.
Class Sample implement Interf
{
{
x=20; //compile time error
}
}
A class can extend only one class at a time .But can interface
can extend any number interfaces.
A class can implement any number of interfaces at a time.But
interface never implement another interface. It will extends
another interface.
Naming conflicts inside interface:
Case 1:
interface Left
{
public void m1();
}
interface Right
{
public void m1();
}
class Central implement Left,Right
{
{
public void m1()
{
}
}
If two interfaces have the two are more same methods ,then only one
method implementation is enough from both interfaces.
Case 2:
The interface having same method name but different arguments.
Interface Inter
{
public void m1();
public void m1(int x);
}
case 3:
Same method name,same arguments but different written types.
Interface Left
{
public void m1();
}
Interface Right
{
public int m1();
}
{
{
public void m1() // error
{
}
public int m1() // error
{
}
}
}
In the above class same method signature m1 is not allow .violation
leads to compile time error.
Exceptional case:
We can’t provide implementation at a time for two or more interfaces
having methods with same signature but different return type .
Variable Naming conflicts:
interface Left
{
int x=10;
}
interface Right
{
int x=100;
}
{
public static void Main(String arg[]
)
{
System.out.println(x); // reference to x is ambiguous both variables
System.out.println(Right.x);
System.out.println(Left.x);
}}
we can resolve variable naming conflicts using interface name.(i.e
instead of x we have to specify left.x or right.x).
Tag Interface Marker/Ability Interface:

If an interface is marked for some ability such type of
interfaces are called maker interfaces or tag interface or
ability interface.
Example: Comparable, Serializable, Clonable
If an interface doesn’t contain any method, it is usually marker
interface. Even though interface contains some methods still
we can use the term marker interface if this interface is
marked for some ability.
Example: Comparable (contains method compareTo())
Adapter classes doesn’t contain concrete methods ,contain
only empty implementation of the methods.
Difference between abstract class and interface:
Interfaces provides more security and high performance when
compare to abstract classes.
Abstract class may contain concrete methods but an interface
never contains any concrete method.
Collection-Interface
The 1.2 release of the Java platform includes a new collections
framework. A collection is an object that represents a group of
objects. A collections framework is a unified architecture for
representing and manipulating collections, allowing them to be
manipulated independently of the details of their representation. The
Collection interface is the root of the collection hierarchy. A Collection
represents a group of objects, known as its elements. Some
Collection implementations allow duplicate elements and others do
not. Some are ordered and others unordered. The JDK doesn't provide
any direct implementations of this interface: It provides
implementations of more specific subinterfaces like Set and List. This
interface is the least common denominator that all collections
implement.
Collection is used to pass collections around and manipulate them
when maximum generality is desired.Collection frame work define
a set classes and interfaces which can be used for
representing a group of objects as single entity. In the case of
c++ the corresponding collection frame work is known as
STL(Standered template library) and collection is known as container.
There are six collection interfaces. The most basic interface is
Collection. Three interfaces extend Collection: Set, List, and SortedSet.
The other two collection interfaces, Map and SortedMap, do not
extend Collection, as they represent mappings rather than true
collections. However, these interfaces contain collection-view
operations, which allow them to be manipulated as collections.
Collection Interface:
It defines general methods ,which can be used for a group of individual
objects. i.e a collection represents a group of individual ibjects.
Note:
Collection is an interface to represent a group of individual objects
where as collections is an utility class for defining utility methods like
sorting, searching.
Collection Interface Methods:
This Interface defines general methods which can be applied on any
collection object.
1.boolean add(Object obj)
2.boolean addAll(collection c)
3.boolean remove(Object o)
4.boolean removeAll(Collection c)
5.void clear()
6.boolean retainAll(Collection c)
removes all the elements in the collection except those present in c.
7.boolean contains(Object o)
8.boolean containsAll(Collection c)
9.boolean isEmpty()
10.int size() returns the number of objects present in the collection
11.Object[] toArray() mainly for improving the performance of the
system.
12. Iterator iterator() to return the objects one by one.
The primary advantages of a collections framework are that it:

• Reduces programming effort by providing useful data structures and
algorithms so you don't have to write them yourself.
• Increases performance by providing high-performance
implementations of useful data structures and algorithms. Because the
various implementations of each interface are interchangeable,
programs can be easily tuned by switching implementations.
• Provides interoperability between unrelated APIs by establishing a
common language to pass collections back and forth.
• Reduces the effort required to learn APIs by eliminating the need to
learn multiple ad hoc collection APIs.
• Reduces the effort required to design and implement APIs by
eliminating the need to produce ad hoc collections APIs.
• Fosters software reuse by providing a standard interface for
collections and algorithms to manipulate them.
SortedMap-TreeMap-Properties
SortedMap:
It is interface.If you want to store the elements based on some sorting
order of keys we should go for the SortedMap.A SortedMap is a Map
that maintains its mappings in ascending key order. It is the Map
analogue of SortedSet. The SortedMap interface is used for apps like
dictionaries and telephone directories.
SortedMap Methods:
1) Object firstKey() //Returns the firstkey of the sortedset
2) Object lasKey() // Returns the last key of the sortedset
3) SortedMap headMap( Object key) //Returns the SortedMap
whose keys are smaller than or equal to specified key
4) SortedMap tailMap( Object key) // Returns the SortedMap whose
keys are greater than or equal to specified key
5) SortedMap subMap( Object key1,Object key2) // Returns a
SortedMap whose keys are greater than or equal to the key1 but less
than key2
6) Comparator comparator(): //Returns Comparator Object that
defines the underlying sorting technique.If the natural sorting order is
used then returns null
TreeMap:
It implements the SortedMap interface.
The underlying datastructure for the TreeMap is Red-Black Tree
Insertion order is not preserved
Duplicate keys are not allowed but values may be duplicated
Heterogeneous objects are not allowed for the keys but values may be
heterogeneous.
As first entry null key insertion is possible to the empty treemap but
after if you try to add any other entry we will get the
NullPointerException
If you are trying to add an entry with the null key to an already exsting
treemap we will get the NullPointerException
There is no restriction for null values
If natural sorting order is used then the keys must be comparable
otherwise classCastException
TreeMap Constructors:
TreeMap map=new TreeMap():
TreeMap map=new TreeMap(Comparatror c):
TreeMap map=new TreeMap(Map m):
TreeMap map=new TreeMap(SortedMap m):
TreeMap Demo program:

package myutil;
import java.util.TreeMap;
public class TreeMapEx1 {

public static void main(String[] args)
{
TreeMap map=new TreeMap();
map.put(new Integer(100),"orange");
map.put(new Integer(200) ,"apple");
map.put(new Integer(300),"grapes");
System.out.println("The TreeeMap Is "+map);
// Try to place the null you will get NullPointerException
// map.put(null,"javasun");
}
}
output:
The TreeeMap Is {100=orange, 200=apple, 300=grapes}
TreeMap Example code with Comparator:

package myutil;
import java.util.Comparator;
import java.util.TreeMap;
class Mycompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Integer i1=(Integer)o1;
return -i1.compareTo(i2);
}
}
public class TreeMapCom {

public static void main(String[] args)
{
TreeMap map=new TreeMap(new Mycompare());
map.put(new Integer(100),"orange");
map.put(new Integer(300),"apple");
System.out.println("The TreeeMap Is "+map);
// Try to place the null you will get NullPointerException
//map.put(null,"javasun");
}
}
output:
The TreeeMap Is {400=grapes, 300=apple, 200=grapes, 100=orange}
Properties:It is the child class of Hashtable For Properties both

keys and values must be Strings
Propertes Constructors:
Properties props=new Properties();
Methods:
getProperty(String key);
setProperty(String key,String value);
propertyNames();
load(InputStream stream);
store(OutputStream stream,String comment);
Properties Demo Program:

import java.util.*;
public class PropertiesDemo {
public static void main(String[] args ){
Properties props=new Properties();
FileInputStream fis=new FileInputStream(“abc.properties”);
props.load(fis);//Load the file
System.out.println(props.getProperty(“orange”));
props.setProperty(“apple’,200);
FileOutputStream fos=new FileOutputStream(“abc.properties”));
}
}
Map-Hashtable-HashMap-WeakHashMap-IdentityHashMap
MAP Interface: A Map is an object that maps keys to values. Maps
cannot contain duplicate keys: Each key can map to at most one
value.
Map is not the child interface of Collection interface
If you want to store the values or objects as key value pairs we go for
the the Map interface
Both key and values are objects
Duplication of keys is not allowed but values may be duplicated
Key –Value Pair is called an Entry
Methods in Map Interface:
1)Object put(Object key,Object value) //Inserts a value into the map.if
the key is already exists it will replace the old values with new one
2)Object get(Object key) // Returns the value associated with the key
otherwise returns null
3)Object remove(Object key) // It removes the entry associated with
the key and returns the corresponding value otherwise returns null
4)boolean containsKey(Object key)
5)boolean containsValue(Object key)
6)int size()
7)boolean isEmpty()
8)void clean()
9)void putAll(Map m)
10)Set keySet()
11)Collection values()
12)Set emptySet()
// The following three methods collection view of Map
13)Object getKey();
14)Object getValue();
15)Object setValue(Object obj)
//Entry is an inner interface present inside the map.It contains
the following three methods which can be applied on the entry object.
16)Object getKey();
17)Object getValue();
18)Object setValue(Object obj)
Note:
interface Map{
Interface Entry{ // inner interface entry
Object getKey();
Object getValue();
Object setValue(Object obj)
}
}
Hashtable:
The underlying datastructure for the HashTable is the Hastable itself.
Heterogeneous values are allowed for both keys and values
null insertion is allowed for both keys and values for the first
element violation leads to NullPointerException
Almost all methods or Hashtable are synchronized hence it is
thread safe Insertion order is not preserved and the objects
are arranged based on hashcode
Duplicate objects for values but keys are not to be duplicated
Hashtable Constructors:
Hashtable table=new Hashtable();
Hashtable table=new Hashtable(int initialCapacity);
Hashtable table=new Hashtable(int initialCapacity,float fillRatio);
Hashtable table=new Hashtable(Map m);
Hashtable Demo:
import java.util.Hashtable;
public class HashtableEx1 {

public static void main(String[] args) {
Hashtable table=new Hashtable();
table.put(new Integer(1),"xxx");
table.put(new Integer(24),"yyy");
table.put(new Integer(3),"zzz");
table.put(new Integer(8),"aaa");
table.put(new Integer(9),"bbb");
table.put(new Integer(2),"sss");
System.out.println("The Hashtable is "+table);
}
}
output:
The Hashtable is {9=bbb, 8=aaa, 3=zzz, 2=sss, 24=yyy, 1=xxx}
HashMap:
The underlying datastructure for HashMap is Hashtable
Duplicate keys are not allowed but values may be duplicated
Heterogeneous key and values are allowed
Null key is allowed only once but values are nulls for any
number of times
HashMap Constructors:
1) HashMap map=new HashMap();
it Create the empty hashmap with the default initial capacity 16 and
fillRatio 0.75
2) HashMap map=new HashMap(int initialCapacity);
it Create a HashMap with the specified nitialCapacity and default load
factor
3) HashMap map=new HashMap(int nitialCapacity,float loadFactor);
4) HashMap map=new HashMap(Map m);
HashMapDemo Program:
import java.util.*;
public class HashMapEx1 {
public static void main(String... args) {
HashMap map=new HashMap();
map.put("orange",new Integer(1000));
map.put("apple",new Integer(2000));
map.put("banana",new Integer(3000));
map.put("grapes",new Integer(4000));
System.out.println("The Map "+map);
System.out.println(map.put(("orange"),new Integer(1001)));
System.out.println("map "+map);
Set s=map.keySet();
System.out.println("The Key Set"+s);
Collection values=map.values();
System.out.println("The Values Are "+values);
Set s1=map.entrySet();
System.out.println("The Entry Set"+s1);
}
}
output:
The Map {orange=1000, grapes=4000, apple=2000, banana=3000}
1000
map {orange=1001, grapes=4000, apple=2000, banana=3000}
The Key Set[orange, grapes, apple, banana]
The Values Are [1001, 4000, 2000, 3000]
The Entry Set[orange=1001, grapes=4000, apple=2000,
banana=3000]
LinkedHashMap:
It is exactly similar to the HashMap except the following differences
HashMap:
Underlying datastructure is Hashtable
While iterating we can not give guarantee for processing
order. Hence we can not use it for caching
LinedHashMap:
Underlying datastructures are hashtable and doubly linkedlist
Insertion order of elements is preserved
While iterating elements we can give guarantee for processing
order.Hence we can use for caching
IdentityHashMap:
In case of HashMap JVM uses the equals() method to identify
the duplicate keys
But if want to use the == operator to identify the duplicates
we go for the IdentityHashMap
Incase of IdentityHashMap two key reference i1 and i2 are
equal if and only if bot i1 and i2 are pointing to the same
object on the heap
IdentityHashMap Demo Program:

import java.util.IdentityHashMap;
public class IdentityHashMapEx1 {

public static void main(String... args) {
IdentityHashMap map=new IdentityHashMap ();
Integer i1=new Integer(10);
map.put(i1,"orange");
map.put(i2,"apple");
System.out.println("The Map"+map);
}
}
WeakHashMap:
WeakHashMap is not a child class of HashMap
HashMap dominates the garbage collector.if any objects are associated
with the HashMap eventhough that object does not have any external
references .Garbage collector is not allowed to destroy that object
But garbage collector dominate the WeakHashMap that is in
case of hashmap if the key is not reachable garbage collector
is allowed to destroy whole entry associated with the key
WeakHashMap Demo Program:
import java.util.WeakHashMap;
class Temp {
public void finalize() {
System.out.println("finalize() Called");
}
public String toString() {
return "Temp";
}
}
public class WeakHashMapEx1 {
WeakHashMap map=new WeakHashMap();
Temp t=new Temp();
map.put(t,"orange");
t=null;
System.gc();
System.out.println("The Map"+map);
}
}
output:
finalize() Called
The Map{}
Collection-List-Vector-ArrayList-Stack-LinkedList
Collection Interface :
The Collection interface is the root of the collection hierarchy. A
Collection represents a group of objects, known as its elements. Some
implement. Collection is used to pass collections around and
manipulate them when maximum generality is desired.

objects.i.e a collection represents a group of individual ibjects.
Note: Collection is an interface to represent a group of individual
objects where as collections is an utility class for defining utility
methods like sorting,searching… etc.
List Interface:
It represents a group of individual objects where

Insertion order is preserved via indexes
Duplicate objects are allowed. .we can differentiate duplicate
objects by using indexes.
A list is also known as sequence ArrayList ,LinkedList ,Vector and Stack
implement List interface.
Following are the methods list interface :
1.boolean add(Object obj)
2.boolean add(int index,Object o)
3.boolean addAll(Collection c)
4.boolean addAll(int index,Collection c)
5.boolean remove(object o)
remove the first occurrence of this object
6.boolean removeAll(Collection c)
7.int indexOf(Object o)
return the index of first occurrence
returns -1 if there is no such object
8.int lastIndexOf(Objetc o)
9.Object get(int index)
there is no get method in the collection interface
10.Object set(int index , Object o)
11.ListIterator listIterator()
12.Object remove(int index)
Vector class:
The underlying datastructure for vector is growable array or resizable
array.
Insertion order is preserved.
Null insertion is possible.
Duplicate objects are allowed.
Hetrogeneous objects are allowed.
It implemented RandomAccess,Clonable and Serializable interfaces.
Best choice for retrieval operation.
Worst choice for insertion or deletion in the middle.
When compare with ArrayList,Vector is preferable when thread safety
is reqired because all the vector class methods are synchronized.
Vector methods:
For adding objects
1.add(Object o) ----> from collection
2.add(int index, Object o) ---------> from list
addElement(Object o) ---------> Vector
for removing objects
1.remove(Object o) ---------> from collection
2.remove(int index) -----------> from list
3.removeElement(Object o) ----------> Vector.
4.removeElementat(int index) -------------> Vector
5.removeAllElements()
6.clear() ------------> from collection
For accessing objects.
1.Object get(int index)
2.Object elementAt(int index)
3.Object firstElement()
4.Object lastElement();
5.int size()
6.int capacity();
Constructors of Vector:
1.Vector v=new Vector()
create an empty Vector with default initial capacity 10.
If the Vector reaches its maximum capacity a new Vector object will
create with a capacity = current capacity * 2 i.e doubles.
2.Vector v=new Vector(int initialcapacity)
Constructs an empty vector with the specified capacity.
3.Vector v=new Vector(Collection c)
4.Vector v=new Vector(int initialcapacity,int incrementalcapacity)
Vector Example:
import java.util.*;
class VectorDemo
{
{
Vector v=new Vector();
v.addElement(“a”);
for(int i=0;i<10;i++)
{
v.addElement(new Integer(i));
}
System.out.println(v);
System.out.println(v.capacity()); // 10
v.add(“b”);
System.out.println(v.capacity()); // 20
}}
Array List: The underlying datastructure for array List is growable array
or resizable array.
Insertion order is preserved.
Null insertion is possible any number of times.
Constructors of ArrayList:
1.ArrayList a=new ArrayListA();
creates an empty arraylist with the default initial capacity 10.
If arraylist reaches its maximum capacity ,it creates a new
arraylist object with the new capacity as (Current capacity *
3/2 ) + 1;
2.arrayList a=new ArrayList(int initialcapacity)
creates an empty arraylist with the specified initial capacity.
3.ArrayList a=new ArrayList(Collection c)
Construct an equivalent arraylist for the given collection object.
ArrayList Example:
import java.util.*;
class ArraylistDemo
{
{
ArrayList a=new ArrayList();
a.add(“aaa”);
a.add(“bbb”);
a.add(“new Integer(10)”);
a.add(null);
a.add(1,”ccc”);
System.out.println(a); // [aaa, ccc,bbb,10,null]
}
}
every collection class implemented clonable and serializable
interfaces.
System.out.println(a instanceOf java.io.Serializable); // true
System.out.println(a instanceOf java.io.Clonable); // true
ArrayList and Vector classes implemented Random Access
interface.Any element in ArrayList and Vector we can access with same
speed.Hence ArrayList is best suitable for retrivel operation.
ArrayList is a non-synchronised one introduced in 1.2 version.It is a
non-legacy class which has high performance.But we can’t achieve
security.Where as vector is a synchronized in 1.0 version .It is a
legacy class which has low performance But we can achive security.
In ArrayList ,there is a possibility for data corruption as it is thread
safe.ArrayList is the worrest choice,If your frequent operation is
insertion or deletion in the middle,because it reqires so many internal
shift operations .
LinkedList:
The underlying data structure for LinkedList is
DoublyLinkedList.
Insersion order is preserved.
Null insertion is possible any number of times.
Hetrogeneous objects are also allowed.
It implemented serializable and clonable interfaces but not
RandomAccess interface.
LinkedList is the best choice if your frequent operation is insertion or
deletion in the middle.
LinkedList the worest choice if your frequent operation retrieval
operation.
LinkedList class contain the following methods for implementing Stacks
and Queues.
1.void addFirst(Object o)
2.void addLast(Object o)
3.Object removeFirst()
4.Object removeLast()
5.Object getFirst()
6.Object getLast()
Constructors of LinkedList:
1.LinkedList l=new LinkedList();
create an empty LinkedList (initial capacity is not applicable) size !=
capacity
2.LinkedList l=new LinkedList(Collection c)
LinkedList Example
import java.util.*;
class LinkedListDemo
{
LinkedList l=new LinkedList();

l.add(“laxman”);
l.add(new Integer(10));
l.add(null);
l.add(0,”scjp”);
l.add(“gorantla”);
l.removeLast();
l.addFirst(“ccc”);
System.out.println(l); // [ccc,gorantla,scjp,10,null]
}}
Stack Class: It is the child class of Vector

Contain only one constructor
Stack s=new Stack();
Methods of stack class:
1.Object push (Object obj)
It pushes an element into stack and that element also return.
2.Object pop()
removes the top of the stack and the object is returned.
3.Object peek()
returns the element present on the top of the stack.
4.boolean empty()
returns true if the stack isempty otherwise false.
5.int search(Object o)
returns the offset from the top of the stack if the Object present else
return -1.
Ex: s.search(“a”);
Stack example:
Import java.util.*;
Class StackDemo
{
{
Stack s=new Stack();
s.push(“a”);
s.push(“b”);
s.push(“c”);
System.out.println(s); // [a,b,c]
System.out.println(s.search(“c”)); // 1
System.out.println(s.search(“a”)); // 3
}
}
insertion order should be preserved should be not LIFO.
treeset-Comparator
SortedSet Interface:
If you want to represent a group of individual,unique set of objects
,where all the objects are in some sorting order (either natural sorting
order or customized sorting order) then we should go for SortedSet.
SortedSet methods:
1.Object first()
returns the first element in sortedset
2.Object last()
return the last element in sortedset.
3.SortedSet headset(Object end)
returns the sorted set containing the elements which are lessthan end.
4.SortedSet tailSet(Object begain)
returns the sorted set that includes the elements which are greaaer
than or equal to begain.
5.SortedSet subset(Object begain,Object End)
return a sortedset that includes the elements which are greater than or
equal to begain but less than end.
6.Comparator comparator()
decribes underlying sorting technique if default sorting technique is
used then it simply returns null.
TreeSet class :
The underlying datastructure for the treeset is balancedtree.
Duplicate objects are not allowed.
Insertion order is not preserved, but all the elements are arranged in
some sorting order.
Null insersion is possible but only one.
Hetrogeous objects are not allowed, voialtion leads to runtime
exception saying classcast exception.
Constructors:
1. treeSet t=new TreeSet()
creates an empty TreeSet where the sorting technique is default
natural order.
2. TreeSet t=new TreeSet(Comparator c)
creates an empty TreeSet ,where the sorting technique is specified by
comparator object .( this is for customized sorting).
3. TreeSet t=new TreeSet(Collection c)
4. TreeSet t=new TreeSet(SortedSet s)
reserved for future purpose.
TreeSet Example:
import java.util.*;
class TreeSetDemo
{
{
TreeSet t=new TreeSet();
t.add(“z”);
t.add(“k”);
t.add(“b”);
t.add(“f”);
System.out.println(t); // [b,f,k,z]
t.add(new Integer(10)); // class cast exception
}
}
In case of integers (10,15,20) it followes ascending order.
TreeSet t=new TreeSet()
t.add(null);
System.out.println(t);
t.add(“a”);
System.out.println(t); // nullpointer exception
Null acceptance:
For the empty TreeSet as the first element we are allowed to add null.
But after adding null if we are trying to add anyother ,we will get a RTE
saying NullPointerException”.If the treeset already contains some
elements,If we are trying to add null causes once again nullpointer
Exception.
In case of StringBuffer objects

t.add(new StringBuffer(‘a”));
t.add(new StringBuffer(“b”));
t.add(new StringBuffer(‘c”));
t.add(new StringBuffer(“l”));
System.out.println(t); // RTE saying classcast exception
i.e In the treeset we should add only.

Homogeneous and comparable objects violation leads classcast
Exception
An object is said to be comparable if an only if the corresponding class
implements comparable interface.
String and Wrapper classes already implemented comparable
interface.But StringBuffer doesn’t implemented comparable interface.
Comparator Interface:
If you want to define our own sorting we havwet to implement
comparator interface.
This interface present in java.util package.
This interface contain the following two methods.a
1.public int compare(Object o1,Object o2)
return –ve number if o1 comes before o2.
return +ve number If o1 comes after o2.
returns zero if o1 and o2 equal.
2.public Boolean equals(Object o)
by using comparator interface we can define our own
customized sorting.
Write a program to insert integer object in the TreeSet where the

Sorting technique is descending order.
import java.util.*;
class TreeSetDemo
{
{
TreeSet t=new Treeset(new MyComparator());
t.add(new Integer(20));
System.out.println(t); // 10 ,20 ,30,100
}
}
class MyComparator implements Comparator
{
public int Compare(Object o1,Object o2)
{
int i1=i1.intValue();
int i2=i2.intValue();
if(i1>i2)
return -1;
else
if(i1 > i2)
return +1;
else
return 0;
}
}
write a program to insert string objects into the TreeSet where the
sorting order is increasing order of String lengths.
import java.util.*;
class ComparatorDemo
{
{
TreeSet t=new Treeset(new Mycomparator())
t.add(“aaaaaa”);
t.add(“bbbb”);
t.add(“ccc”);
System.out.println(t); // [ccc,bbbb,aaaaaa]
}
}
{
{
String s1=(String)o1;
String s2=(String)o2;
if(s1.length() < s2. length())
return -1;
else
if(s1.length() > s2.length())
return +1;
else
return 0;
}
}
program to insert StringBuffer Objects in the treeSet according to

dictionary order
import java.util.*;
class ComparatorDemo
{
{
TreeSet t=new TreeSet(new MyComparator());
t.add(new StringBuffer(“aaa”);
t.add(new StringBuffer(“bbb”);
t.add(new StringBuffer(“ccc”);
t.add(new StringBuffer(‘ddd”);
System.out.println(t);
}
}
{
{
String s1=o1.toString();
String s2=o2.toString();
return s1.compareTo(s2);
//return s2.compareTo(s1);
}
}
if we return always like this:

return 0; // aaa
return +100 // bbb,ccc,aaa,ddd
return -100 // ddd,aaa,ccc,bbb
collection-set-HashSet-LinkedHashSet
Collection Interface:
The Collection interface is the root of the collection hierarchy. A
Collection represents a group of objects, known as its elements. Some
implement. Collection is used to pass collections around and
manipulate them when maximum generality is desired.

objects.i.e a collection represents a group of individual ibjects.
Note:
Collection is an interface to represent a group of individual objects
where as collections is an utility class for defining utility methods like
sorting,searching… etc.
Set Interface:
A Set is a collection that cannot contain duplicate elements. As you
might expect, this interface models the mathematical set abstraction.
It is used to represent sets like the cards comprising a poker hand, the
courses making up a student's schedule, or the processes running on a
machine.
This interface doesn’t contain any new methods.we have to use

collection interface methods.
Hash Set:
The underlying data structure for the set is Hashtable.
Elements are inserted based on the hash code, hence insertion
order is not possible.
If we are trying to add a duplicate object no chance of getting RTE or
CTE add() just simply returns false.
Null insertion is possible but only once.
HashSet is the best choice for searching operations.
Hashset implemented serializable and clonable interface.
Constructors:
1.HashSet h=new HashSet();
Creates a new empty HashSet with default initial capacity 16
and load factor or fill ratio 0.75.
2.HashSet h=new HashSet(int initialcapacity);
Creates an empty HashSet with specified initial capacity and default fill
ratio is 0.75.
3.HashSet h=new HashSet(int int itialcapacity,float fillratio)
creates an empty HashSet with the specified initial capacity and
specified fill ratio.
4.HashSet h=new HashSet(Collection c)
HashSet Example:
import java.util.*;
class HashSetDemo
{
{
HashSet h=new HashSet();
System.out.println(h.add(“b”); // true
h.add(“b”);
h.add(“c”);
h.add(“d”);
h.add(null);
h.add(new Integer(10));
System.out.println(h.add(“d”); // flase
System.out.println(h); // depends on hash code number insertion order.
}
}
Linked Hash Set:

The linked hash set is exactly similar to HashSet Except the following
differences.
Hashtable is the underlying data structure of
hashset.Hashtable and doubly linkedlist are the underlying
datastructures for linkedhashset.
In the above demo LinkedHashSet l=new LinkedHashSet();
Then the output: [b,c,d,null,10] preceding with true and flase.i.e
insertion order is preserved.
We can use LinkedHashSet for implementing caching memory.
Comparable Interface and clonable interface

Comparable Interface:
This is present in java.lang.package
Contains the following one method.
1.public int compareTo(Object o)
if returns –ve integer if o1 has to place before o2.
If returns +ve integer if o1 has to to place after o2.
If returns zero then o1 and o2 are equal.
All the wrapper classes and string class already implemented
comparable interface. But the StringBuffer doesn’t implement
comparable interface.
Comparable Interface Example:
Interface comparable
{
public int compareTo(Object o)
{
TreeSet t=new TreeSet(0;
t.add(“a”);
t.add(‘z”);
System.out.println(t); // a,z (:: z.compareTo(“a”);)
System.out.println((“a”).compareTo(“z”)); //-25
System.out.println((new Integer(10).compareTo(new Intege(1)); // +1
}
}|
Marker or Tag Interface:
If an interface is marked for some ability such type of interfaces are
called Marker interfaces.
Ex: clonable,serializable
If an interface with out any method obviously accept ass marker
interface.
Eventhough interface contains some methods,still we can consider as
marker interface .If it is marked for some ability.
Ex:Comparable interface.
Intreger i1=new Integer(10);
System.out.println(i2.compareTo i1); // -1
System.out.println(i1.compareTo i2); // +1
System.out.println(i1.compareTo i1); // 0
System.out.println(i1.compareTo(“a”)); // CTE nullpointer exception
Cloneable interface:
Cloning in programming uptaining bit wist exact copy of an
object is called cloning.
cloning Example:
Class sample() implements cloneable
{
Int i=10;
Public static void main(string args[])throwsClone
notSupportedEexception
{
Sample s1=new sample();
Sample s2=s1;
Sample s3=(sample)s1.clone();
S1.i=1000;
System.out.println(s3.i);
System.out.println(s1==s3);
we should type cast otherwise
CTE:in compatable types
Found: Object reqired=sample
The class must implements cloneable interface otherwise at runtime
clone() results cloneNotsupportException
Example:
Class sample implements clonable
{
Int i=10;
Public static void main(string[]args)throws cloneNot support Exception
{
Object o=new object();
Object o2=o.clone();
}
CTE:clone() has protected access in java.lang.object
The protected numbers we can access, from with in the same package
or from outside package but from outside package,the protected
number can be accessed b using child class reference only.ie we can’t
use parentclass reference to access protected number from outside
package,validation leadsto CTE.
clone() method:
Protected object clone() throws clone not supported exception.
This method can used to prouduced exactly duplicate copy of an
object..
All the objects can’t produce cloned object ,only clonable objects can
produce duplicate copies .
An object is said to be conable if and only if the corresponding
class implements clonable interface.
By using the folling object class clone() method we can produced
cloned objects
Protected object clone() throws clone supported exception
CheckedException so we should handle by using try catch or throws to
the caller by using throws clause.
Shallow cloning Example:
Class Student implements cloneable
{
String name;
String age;
Student(String name,String age)
{
This.name;
This.age=age;
]
Public Object clone()throws cloneNotSupportedException
{
Return this;
}
}
Class Student cloneDemo
{
Student s1= new Student(“hai”,”22”);
Student s2= (Student)s1.clone();
S2.name=”abc”;
System.out.println(s1.name);
Public static void main (String ar[])
{
StudentCloneDemo s1= new Student cloneDemo();
}
}
Deep cloning example:
{
String name;
String age;
}
Student(String name ,String age)
{
This.name=name;
This.age=age;
}
Public Object clone(0throws CloneNotSuport Exception

{
try
{
ByteArrayOutputStream bas=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bas);
Oos.writeObject(this);
ByteArrayInputStream bias=new
ByteArrayInputStream(bas.toByteArray());
ObjectInputStream oos=new ObjectInputStream(bias);
Return ois.readObject();
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
class DcloneDemo
{
DcloneDemo()throws CloneNotSuportException
{
Student s1=new Student(“hello”,”200”);
Student s2=(Student)s1.clone();
S2.name=”java”;
Public static void main(String[] arg)
{
new DcloneDemo();
}
}
Iterator,ListIterator,Enumeration
Enumeration:
This is cursor to retrive the objects one by one.
This interface contains the following two methods.
1.boolean hasMoreElements();
2.Object nextElement();
Enumeration Example:
Import java.util.*;
Class EnumDemo
{
{
Vector v= new Vector();
For(int i=0;i<=10; i++)
{
v.addElement(new Integer(i);
}
System.out.println(v); // [0,1,2,3…….10]
Enumeration e=v.elements();
While(e.hasMoreElements())
{
Integer i=(Integer)e.nextElement();
If(i.IntValue() % 2 ==0)
{
}}}
Limitations:
1. We can get Enumeration Object only for legacy classes
(Vector,Stack,Hashtable,Properties,Dictionary,Enumeration)
2. While iterating the Objects of enumeration we can get only read-
access.
i.e while iterating we are not allowed to perform any remove or modify
operation.
Iterator:
This can be applied for any collection implemented class (legacy
and non-legacy)
While iterating the objects we are allowed to perform remove
operation also, in addition to read operation.
This interface contain the following there methods
Boolean hasNext()
Object next();
Void remove()
Iterator Example:
Import java.util.*;
Class IteratorDemo
{
{
ArrayList l=new ArrayList();
for(int i=0;i<=10;i++)
{
l.add(new Integer(i);
}
System.out.println(i); // 0,1,2,3,……9
Iterator itr=l.iterator();
While(itr.hasNext())
{
Integer i=(Integer)itr.next();
If(i.intValue() % 2==0)
{
}
else
{
itr.remove();
}
}
System.out.println(l); [0,2,4,6,8]
}
}
}
List Iterator:
List iterator is the child interface of iterator .this can be
applicable only for list implemented classes
(arraylist,linkedlist,vector and stack).
This is a bidirectional cursor .we can move either to forward or
backward direction
While iterating ,we are allowed to replace existing element with the
new element ,we are allowed to add new elements and still we can
perform remove operation also.
ListIterator defines the following methods.
1.boolean hasNext();
2.boolean hasPrevious();
3.Object next();
4.Object previous();
5.int nextIndex();
if there is no next element it just simply return the size of the list.
6.int previousIndex()
Return -1 if there is no previous index.
7.void remove()
8.void set()
9.void add()
ListIterator Example:
Import java.util.*;
Class ListIterDemo
{
{
LikedList l=new LinkedList();
L.add(“laxman”);
l.add(“chandu”);
l.add(“ravi”);
l.add(“raju”);
System.out.println(l);
ListIterator lt=l.listIterator();
While(lt.hasNext())
{
String s=(String)lt.next();
If(s.equals(“laxman”))
{
lt.remove(); or lt.set(“scjp”);
}
}
}
}
Thread creation
Multitasking:
* Executing several tasks simultaneously is the concept of Multitasking.
* The main objective of multitasking is to decrease response time of
the system, so that the performance of the system will increase.
Process Based Multitasking:-
* Executing several tasks simultaneously where each task is a
independent program.
* Example typing a java program in the Editor, playing MP3 player,
Downloading a file from the internet
* All the tasks are independent of each other and executes
simultaneously.
* This type of multitasking is useful at OS level.
* CGI fallows process based multitasking.
Thread Based Multitasking:-
* Executing several tasks simultaneously, where each task is a
separate inependent part of the same program. That independent part
is called the Thread.
* Servlets followThread Based MultiTasking.
* Java itself provide support for multithreading by introducing several
library classes.
* We can use in games/animation programme.
* Creating a thread in two ways.
1. By extending Thread
2. By implementing Runnable
Methods used to prevent a thread from execution:
* yield()
* join()
* sleep()
* Synchronization
* InterThread communication (wait, notify, notifyAll)
Defining, Instantiating and starting Thread by extending Thread class:

class MyThread extends Thread
{
public void run()
{
System.out.println("child job”);
}
}
Here run method is the heart of thread where you have to define the
job.
class Sample
{
{
MyThread t=new MyThread();
t.start(); //starting a thread
System.out.println(“Main thread job”);
}
}
The above program executes well.it gives the output mainthread
job,child job,.........
Difference between t.start() & t.run()?
• If we call t.start(), it will create a new Thread and that thread is
responsible for execution of run().
• If we call t.run(), mo new thread will create, the main thread only will
execute run(), just like a normal method.
• In case of t.start() output we can’t expect
• In case of t.run() output Child Thread 10 times fallowed by main
thread 10 times.
Thread class start():-

public void start()
{
1. Registering our thread with the thread scheduler then only thread
scheduler allocate CPU and memory type of resources for this new
thread also.
2. calls run()
}
If we over ride start method in the above example:
--->public void start()
{
System.out.println(“start method”);// start method 1 time, main thread
10 times
}
--->public void start()
{
super.start();
System.out.println(“start method”);// start method child & main thread
alternatively
}
{
{
t.start();
}
}
• Thread class run() has empty implementation that’s why we are
getting no output.
Defining, Instantiating and starting Thread by implementing Runnable
Ex: class MyRunnable implemts Runnable
{
public void run()
{
for(int i=0; i<=10 ;i++)
System.out.pritnln(“child thread”);
}
}
class ThreadDemo
{
{
MyRunnable r=new MyRunnable();
r.start(); // compile time errror
Thread t=new Thread(r); ---> Target Runnable
for(int i=0 ; i<=10 ; i++)
{
System.out.println(“main thread”);
}
}
} In the above example instead of r.start we place r.run();
//childThread (no new thread will create ) In the above example we
place the
* t.start(); //valid (new thread will create child thread)

* t.run(); // child thread (no new thead will create)
• Among the above two probabilities of creating thread it is highly

recommended to use implements Runnable mechanism.
• In the first case ( extends thread), our thread class extends
Java.Lang.Thread, hence no chance of extending any thing else. Hence
we are missing, the key benefit of oop’s concept ie., inheritance.
Lifecycle of Thread:
• Once the thread is started, there is no chance of starting the same

thread once again. // we can start thread onetime only.
Violation leads to RTE saying Illegal Thread State Exception”.
• Thread t= new Thread();
t.start(); //no o/p
Thread class Constructors:

1. Thread();
2. Thread(Runnable r);
3. Thread(String name);
4. Thread(Runnable r, String name);
5. Thread(ThreadGroup g, String name);
6. Thread(ThreadGroup g, Runnable r);
7. Thread(ThreadGroup g, Runnable r, String name);
Ex:- // Test king
{
public void run()
{
System.out.println(“run”);
}
}
class ThreadDemo
{
{
MyThread t= new MyThread();
Thread t1=new Thread(t);
t1.start();
// t1.run(); ----> It is just like a method no new thread will create
}
}
Setting & getting the name of a thread:
Thread class contain the fallowing methods for setting & getting the
name of the Threads..
* public final String getName();

* public final void setName(String s);
Thread class yield , join , sleep.

Thread Priorities:
• Thread class contains the fallowing methods for setting and getting
priority of a thread.
public final int getPriority();
public final void setPriority(int i);
• The valid range for the thread priorities 1 to 10 (1 is atleast and 10 is
the highest)
• Thread class contains the fallowing predefined priority constraints.
MAX-PRIORITY ----> 10
NORM-PRIORITY ----> 5 (default)
MIN-PRIORITY ----> 10
• If you are trying to set the priority as greater than 10 or lessthan1,
then we will get a RTE saying “Illegal Argument Exception”
Example:
{}
class Sample
{
{
Thread.currentThread().setPriority(10);
System.out.pritnln(Thread.currentThread().getPriority());
MyThread t= new MyThread();
System.out.pritnln(t.getPriority());//10 10
}
}
• The default priority for the maintained is 5. But we are allowed to
change the prority by using setPriority()
• The priority of any the thread is inherited from the parent thread.
• Thread scheduler uses these proroites to allocate CPU. The thread
which is having highest priority will get executes first.
t1.setPriority(10);
Yield() :
We can prevent a thread from execution by using one of the fallowing
methods.
1. yield()
2. join()
3. sleep()
• The thread which is executing yield() causes the current
thread temperarly pause and allow other waiting threads
of same or high priority to execute.
• If there is no waiting thread, the same thread will
execute immediately.
• If all the remaining threads are having low priority, then
the same thread once again will execute.
Method Signature:-
public static native yield();
• If the thread calls yield(), the thread going to ready

state.
yield method example:
Class MyThread extends Thread
{
public void run()
{
{
System.out.pritnln(“child thread”);
Thread.yield();
}
}
}
class SampleDemo
{
public static void main (String a[])
{
MyThread t = new MyThread();
t.start();
for(int i=0;i<10;i++);
{
System.out.pritnln(“main thread”);
}
}
}
• The yield() depends upon underlying platform. Some platforms
may not support .Breaks java’s programme independency.
join:
• If any executing thread calls join method on any thread
t, the current thread will go to the blocked state until t
completes.
Method Signature:
public final void join() throws InterruptedException
public final void join(long ms)throws InterruptedException
public final void join(long ms, int nanosec)throws
InterruptedException
join Example:
{
public void run()
{
{
System.out.println(“sita thread”);
try
{
Thred.sleep(1000);
}
catch(InterruptedException e){}
}
}
}
class JoinDemo
{
{
t.start();
t.join(); //or t.join(3000);
for(int i=0;i<10;i++);
{
System.out.println(“Rama thread”);
}
}
}
sleep():-
• The thread which is executing sleep() will go to the
sleep for the specified amount of time.
MethodSignature:
public static void sleep(long ms) throws InterruptedException
public static void sleep(long ms, int nanoseconds)throws
InterruptedException
sleep example:
{
public void run()
{
{
System.out.println(“child thread”);
try
{
Thread.sleep(1000);
}
}
}
}
class SleepDemo
{
{
t.start();
}
}
interrupt():
• The thread can interrupt any sleeping/waiting/blocked for
joining by the fallowing thread class method.
public void interrupt(); //this is instance method
interrupt example:
{
public void run()
{
{
System.out.println(“child thread”);
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
System.out.println(“I got interrupted”);
}
}
}
}
class SleepDemo
{
{
t.start();
t.interrupt();
}
}
summsrization table:
Thread Synchronization
Synchronization:
The keyword synchronized can be apply only for methods and
blocks. Ie., We can’t apply synchronized keyword for the
classes and variables.
If a method (or block) declared as the synchronized at a time
only one thread is allowed to execute that synchronized area
on any given object.
Advantage: Prevent data corruption, achieve security.
Limitation: Because of synchronized keyword 2 threads are not allowed
to execute concurrently on any object, hence the waiting time of the
threads will increase, which results in low performance of the system.
A class can contain both synchronized and non synchronized methods.
If a thread calls synchronized method on any object, first this thread
got the lock, it is allowed to any synchronized method on that object.
If a thread executing any synchronized method on the given object at
that time no other thread is allowed to execute any synchronized
method on that object.
If a thread executing any synchronized method the remaining
threads are allowed simultaneously to execute nay non
synchronized method on that object.
Every Object in java has a lock. At the time of synchronization only the
lock concept will conme into the picture.
Synchronization example:-
class Display
{
public synchronized void show(String name)
{
{
System.out.println(“Good Morning:”);
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.show(name);
}
}
class SynchronizedDemo
{
{
Display d=new Display();
MyThread t1=new MyThread(d,”java”);
MyThread t2=new MyThread(d,”Sun”);
t1.start();
t2.start();
}
}
output:
good morning : java ......10 times after good morning: sun ......10 times
If we are not putting synchronized keyword we will get some irregular

output like
goodmorning :good morning:java good morning:sun..........like that
Class Level lock:

• If you want to execute any static synchronized method, first the
thread should required a class level lock.
• If a thread has class level lock, it is allowed to execute any stock
synchronized method. During that time no other thread is allowed to
execute any static synchronized method. But the remaining threads
are allowed to execute any static non synchronized methods of the
same class.
thread communication wait , notify , notifyall

Two threads can communicate with each other by using wait(),
notify(), notifyall() methods Signatures.
Public final void wait() throw interepedException.
Public final native void wait(longms)throws InterruptedException.
Public final void wait(long ms,int ns)throws InterruptedException.
Public final native void notify();
Public final native void notifyAll();
Why this methods are in objclass instead of threadclass?
Wait(),notify();notifyAll() cantain in object class,not in the
thread class.because these methods can be applied on
common shared object,not on the thread.
Inorder to call wait(),notify(),notifyAll() on an object, we should be the
owener of that object.
We are allowed to call wait(),notify(),notifyAll() methods from
the synchronized context only(then only we will get the lock of that
object and we will beome owner of that object )
If we call wait(),notify(),notifeAll() from non synchronized context,we
will get a run time Exception saying”illegal monitar state Exception:
not a owner”
If the thread call wait()method,first it releases the lock and thenit will
go for waiting state, if the waiting thread gets ‘notification call’ or time
expired’ or’got interruption’ then it will go for another blocked state for
getting lock.
Once the thread got the lock, it will go to the ready state.
After calling wait method immedeatly releases the lock but after giving
notify call the thread may not the lock immediately.
The only method which causes the releasing of lock is wait()
method.
But in the case of sleep(),join() or yield() the thread never
releases the lock.
Method results release of lock:
Wait()
Join()
Sleep()
Yield()
Notify() // releases the lock, but may not immediatly
noifyAll()
A thread can acquire more then one lock at time .a thread releses the
lock of an object on which it calls the wait()method .it run releses all
the locks.
Example:
Class Thread A
{
Public static void main(string[]args)throws interrupted Exception
{
ThreadB b =new threadB();
b.start();
synchronized(b)//thread got lock
{
System.out.pritnln(“iam calling wait method”);
b.wait();
System.out.pritnlnpln(“I got notification);
}
System.out.pritnlnpln(b.total);
}
}
Class ThreadB extends Thread
{
Int total=0;
Public void run()
{
Synchronized (this).//.thread got lock
{
System.out.pritnln(“iam starting calculation”);
for(int i=0;i<=1000;i++)
{
Total=total+i;
}
System.out.pritnln(“iam giving notification call”);
notify();//thread releases lock again
}
}
} //500 500.
Flow -- > 0 -->1 --> 2 --> 3 --> 4 ---> 5
Daemon Thread
The threads which are executing in the background to provide
support for user defined threads are called daemon threads.
Ex: garbage callector
Thread class contain the following method for checking whether the
given thread is daemon or not
Public final Boolean isDaemon();
Daemon thread Example:
Class DaemonThread
{
Public static void main(string []args)
{
s.o.pln(thread .currentThread().isDaemon());
}
}
Usually daemon threads runnigg with low priority but based on our
requirement we can give high priority also,The daemon nature is
inherited from the parent..ie of the parent is the daemon thread then
the child also daemon thread and the parent n non-daemon by default
child also non-daemon. // Child and parents should daemon incase of
daemon
Based on our requirement we are allowed to change the daemon
nature of any thread b the following method.
Public final setDaemon(Boolean b);
if b is true the thread will become daemon otherwise non-Daemon
Example:class sample extends thread
{
{
Public static void main(String[] a)
{
t.start();
t.setDaemon(true);
System.out.println(t.asDaemon());
we are not allowed to change Daemon nature after starting a
thread,validation leads to RTE saying “illegal thread state Exception”
ie we are not allowed to change Daemon nature of main method it is
already started at the beginning only.
Whenever the last non-Daemon thread dead all the Daemon threads
will be terminated automatically
Class MyThread extends Thread
{
Public void run()
{
For(int i=0;i<10;i++)
{
s.o.pln(“childmethod”);
try
{
Thread.sleep(2000);
}
Catch(InterruptedException e) {}
}
}
}
Class DaemonThreadExample
{
public static void main(string[]args)threads IE
{
MyThread t=new Thread();
System.out.println(t.isDaemon());
t.setDaemon(true);
t.start();
thread.sleep(5000);
System.out.println(“end of main thread”);
}
}
After starting the thread we are allowed to change the priority
of a thread but not allowed to change the Daemon nature.
Thread DeadLock
If two threads are waiting for each other forever, that situation is
considered as deadlock.(a lock without key is the deadlock)
We can present the dead lock occurrence but we const resolve.
Dead lock Example:
Class A
{
Public synchrozied void foo(B b)
{
System.out.println(“thread t1 entered into foo”);
try
{
Thread.sleep(2000);
}
catch(IE e){}
System.out.println(“thread t1 calling B’s last method”)
b.last();
}
Public synchronized void last()
{
System.out.println(“a class last method”);
}
}
Class B
{
Public synchronized void bar(A a)
{
System.out.println(“thread t2 entered into bar”);
try
{
Thread.sleep(2000);
{
Catch(intereped Exceptiom e){}
System.out.println(“thread t2 calling Ab last method);
a.last();
}
Public synchronized void last()
{
System.out.println(“B class last method”);
}
}
class DeadlockExample
{
A a=new A();
B b=new B();
DeadLock(){
Thread.currentThread().setName("main thread");
Thread t=new Thread(this);
t.start();
b.bar();
}
Public static void main(string[]args)
{
Deadlock d=new Deadlock();
}
Public void run()
{
a.foo(b);
}
}
thread group
Every Java thread is a member of a thread group. Thread groups
provide a mechanism for collecting multiple threads into a
single object and manipulating those threads all at once,
rather than individually. For example, you can start or suspend all
the threads within a group with a single method call. Java thread
groups are implemented by the thread group class in the java.lang
package.
The runtime system puts a thread into a thread group during thread
construction. When you create a thread, you can either allow the
runtime system to put the new thread in some reasonable default
group or you can explicitly set the new thread's group. The thread is a
permanent member of whatever thread group it joins upon its
creation--you cannot move a thread to a new group after the thread
has been created.
The Default Thread Group:
If you create a new Thread without specifying its group in the
constructor, the runtime system automatically places the new thread
in the same group as the thread that created it (known as the current
thread group and the current thread, respectively). So, if you leave the
thread group unspecified when you create your thread, what group
contains your thread?
When a Java application first starts up, the Java runtime system
creates a ThreadGroup named main. Unless specified otherwise, all
new threads that you create become members of the main thread
group.
Creating a Thread Explicitly in a Group
A thread is a permanent member of whatever thread group it joins
when its created--you cannot move a thread to a new group after the
thread has been created. Thus, if you wish to put your new thread in a
thread group other than the default, you must specify the thread group
explicitly when you create the thread. The Thread class has three
constructors that let you set a new thread's group:
public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group, String name)
public Thread(ThreadGroup group, Runnable target, String
name)
Each of these constructors creates a new thread, initializes it based on
the Runnable and String parameters, and makes the new thread a
member of the specified group. For example, the following code
sample creates a thread group (myThreadGroup) and then creates a
thread (myThread) in that group.
ThreadGroup myThreadGroup = new ThreadGroup("My Group of
Threads");
Thread myThread = new Thread(myThreadGroup, "a thread for my
group");
The ThreadGroup passed into a Thread constructor does not
necessarily have to be a group that you create--it can be a group
created by the Java runtime system, or a group created by the
application in which your applet is running.
Thread group Example:
public class ThreadGroupDemo {
class MyThreadGroup extends ThreadGroup {

public void uncaughtException(Thread t, Throwable ex) {
System.err.println("I caught " + ex);
}
public MyThreadGroup(String name) {
super(name);
}
}

new ThreadGroupDemo().work();
}
protected void work() {

ThreadGroup g = new MyThreadGroup("bulk threads");
Runnable r = new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + " started");
for (int i=0; i<5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
try {
Thread.sleep(1776);
} catch (InterruptedException ex) {
System.out.println("Huh?");
}}}};
// Create and start all the Threads

for (int i = 0; i< 10; i++) {
new Thread(g, r).start();
}
// List them.
Thread[] list = new Thread[g.activeCount()];
g.enumerate(list);
for (int i=0; i) {
if (list[i] == null)
continue;
Thread t = list[i];
System.out.println(i + ": " + t);
}
}
}
object class
Java.lang.package contain several utility classes which are mandatory
for writing simple to complex programs.There is no need to import
java.lang.package as by default it is available to our program
Java.lang.object class: It is super class of any java class .all the
predefined classes are user defined classes either directly or indirectly
extends java.lang.objectclass
This class contain several utility methods which can be applied on any
java object.
.for every class parent class in object class
Class A extends B
{
// code
}
Means, Ie.for B,parent is object but for A parent is B only .so java
supports multilevel inheritance
The following are the 11 methods present in object class
1).public string to string()
For string representation of object.
2)public native int hashcode()
Returns the hashcode of an object
3)public Boolean equals(object obj)
For comparing the current object with the specified object
4)protected native object clone() throws clonesoft support Exception
To produced cloned object
5)protected void finalize()throws throwable
6)public final native class getclass()
7)public final viod wait()throws interrupted exception
8)public final void wait(longms)throws interrupted exception
9)public final void wait(long ms,int ns)throws interrupted exception
10)public final native void notify()
11)public final native void notifyAll()
1.tostring():
to String Example:
Class Sample
{
String name;int rollno;
Student(string name,int rollno)
{
This.name=name;
This.name=rollno;
}
{
Student s1=new student(“visvam”,101);
System.out.println(s1);
}
Public string tostring()
{
//return get class().getName()+’@’+
Integer.toHexstring(hashcode());
//return”this is student object”;
Returnname+”……”+rollno;
}
2.Hashcode():
HashCode Example:
String s1=new string(”visvam”);
String s2=new string(“visvam”);
System.out.println(s1.hashcode());
System.out.println(s2.hashcode());
hashcode()---when ever an object is created jvm allocates a number for
that object which is considered as hashcode().
Most of the cases the hashcode saving is unique for every object
Jvm uses this hashcode while saving objects to hashtable, hashmap or
hashset.
Hashcode never represents the address of an object.
Oppropriate way of overriding of hashCode method:
Ex: class Student
{
String name,int rollno;
Student(string name,int rollno)
{
This.name=name;
This.name=rollno;
}
Public int hashcode()
{
return rollno
}
Public string tostring()
{
return name+”-----“+rollno;
}
{
String s1=new string(“java”,101);
{
System.out.println(s1); // java ...... 101
}
Public int hashcode()
{
retuen rollno;
}
It is highly recomonded to override hashcode .In our classes.overriding
hashcode is appropriate if and only if every object we have to assign a
different hashcode.This is helpful for the jvm to save object in
hashcode,hashmap,hashset and serching also.
3.Equals()
Student s1=new student(“viswam”,101);
Student s1=new student(“surya”,102);
Student s1=new student(“surya”,102);
System.out.println(s1==s2); // false
System.out.println(s1.equal(s2)); // false
System.out.println(s2==s3); // false
System.out.println(s2.equals(s3)); // false
System.out.println(s2==s2); // true
System.out.println(s2.equals(s2)); // true
= = Operator:
This is meant for reference comparision always s1==s2 is true if and
only ig both s1 and s2 pointing to the same object on the heap.
Ex: string s1=”visvam”;
Thread t1=new Thread()
System.out.println(s1==t1);
we can’t apply==operator for incomparable types.validation leads to
CTE saying incomparable types.
S1==null is always “false”(no CTE&RTE)
equals()method :
The equals method available in object class meant for reference or
address comparision only(similar to==operator)but,we can override
equals() in our class for content comparision.
Overriding of .equals()
===> public Boolean equals(object o)
{
String name1=this.name;
Int rollno=this.rollno;
Student name2=s2.name;
Int rollno2=s2.rollno;
If(name1.equals(name2)&rollno1==rollno2)
Return true;
else
return false;
}
===>then System.out.println(s2.equals(s3)); //true
System.out.println(s1.equals(s2)); // false
====> in string class. .Equals() method is already overridden for
context comparision. Object class.equals method. Satisfy the following
two conditions.
1.this is always for address comparision
2.it never rise CTE&RTEs even the arguments are different types.
If the arguments are different types .equals() is simply return false.
public boolean equals(object o)
{
try
{
Name 0=this.name1;
Rollno1=this.rollno1;
Student s=(student)0;
Name2=this.name2;
Rollno2=this.rollno2;
If(name1.equals(name2)&rollno1=rollno2)
return true;
else
return false;
}
Catch(classcastException e)
{
return false;
}
}
Then==>s.o.pln(s1.equals(“visvam”));
Catch(nullpointerException e)
{
Return false;
}
Then==> s.o.pln(“null”));
Comparision between==Operator &.equal :

= = Operator :
1.we can apply for both primitation and object references
2. r1= =r2 is true if and only both r1,r2 pointingly to same object on
the heap. ie ==is always for reference comparision.
3.we cant’t override for context comparision.
4.we can’t apply = = operator for different tpes of objects
.incomparable types.
5.s1= =null is always false
.equals()
1.we can apply only for object references
2.by default ,.equals() present in the object class is meant for address
comparision onl
3.we can override .
4..equals()never release any CTE&RTEs even the arguments are
different types .in that situation it will just simply return false.
5.s1.equals(null) gives false when handle NPE through catch
Relationship between = =and .Equals
1. if r1==r2 is true then r1.equals(r2) is always true.
2. if r2 = = is false then r1.equals(r2) may returns true.
Contract between hashcode and .equals()
If r1=equals(r2) is true,then r1.hashcode() = = r2.hashcode();
Ie .equalent objects should alwas have same hashcode.
If r1.equals(r2) is false ,then their hashcode may be same.
If R1.hashcode() = = r2.hashcode() may returns true
If R1.hashcode() = = r2.hashcode() may returns true ,then
r1.equals(r2)may be true.
If R1.hashcode() = = r2.hashcode() may returns false,then
r1.equals(r2)alwas false.
In order to satisfy the above contract we have to override
hashcode() whenever we are overriding .equals()
4.clone()
object..
An object is said to be conable if and only if the corresponding
class implements clonable interface.
By using the folling object class clone() method we can
produced cloned objects
String class
String class it is there in Java.lang package.
Immutability of the String object:
String s=”java”;
s.concat(“soft”);
System.out.println(s);
output:- jaVa
Muatability of StringBuffer object:
StringBuffer s=new StringBuffer(“java”);
s.append(“soft”);
output:- javasoft
Once we created a string object we are not allowed to perform any
changes in the existing String object.
If you want to perform any changes (by using concat() or any other),
with the changes a new String object will create.
Hence String objects are considered as Immutable
In the case of StringBuffer, once we created a StringBuffer object, we
are allowed to perform any changes in the existing StringBuffer object
only.
Hence StringBuffer object is mutable
1. String s1=new String(“java”);
2. String s2=new String(“java”);
System.out.println(s1==s2); --> false
System.out.println(s1.equals(s2)); --> true
But
3. StringBuffer s3=new StringBuffer(“viswan”);
4. StringBuffer s4=new StringBuffer(“viswan”);
System.out.println(s1==s2); --> false
System.out.println(s1.equals(s2)); --> false
In the String class .equals() is overridden for content comparision. Here
the content of s1 and s2 are equal, that’s why s1.equals(s2) returns
true.
In the String class .equals() is not overridden for content comparision.
whenever we calling .equals()
Method on the StringBuffer object, Object class .eqauals() method will
execute, which is meant for address comparision only.
Hence s3.equals(s4) returns false eventhough the contents of s3 and
s4 are same.
Difference between the ways of creating String objects:-
1. String s1=”durga”;
2. String s2=new String(“durga”);
• In the first case, the JVM will check, is the any String object
with content durga in the “String Constant Pool”. If there is no
such object then only a new String object will create and s1
will pointed to that object.
• If the object already present then s1 will simply refers to that
object instead of creating a new object.
• In the second case, two String objects will create, one is on
the heap, for the other one in the “String Constant Pool” (If
the object is not already present) and s2 will pointing to heap
object.
Ex: String s=”viswan”;
s.concat(“sw”);
* In this content, three objects are created. One is on heap and another
two on “String Constant Pool”
• “String Constant Pool” never allows Garbage Collection.
• Heap durgasw String Constant Pool software
• I the object does not have any references in the “String
Constant Pool”, still this is not eligible for the Garbage
Collection.
• All the objects present in the “String Constant Pool” destroy,
whenever the JVM restarted.
What is the output and how many String objects are created.
String s1=”spring”;
String s2=s1+”summer”;
s1.concat(“fall”);
s2.covcat(“s1”);
s1+=”winter”;
System.out.println(s1+ “,”+s2);
output: spring , springsummer
string constant pool: spring, summer, fall, winter
Heap: springsummer, springfall, springwinter, springsummerspring
Advantage Of StringConstantPool:
String s1=”you can’t change me”;
String s2=”you can’t change me”;
System.out.println(s1==s2); // true
System.out.println(s1.equals(s2)); //true
String s3=new String(“you cannot change me”);
System.out.println(s1==s3);//false
System.out.println(s1.equals(s3)); //true
String s4=”you can’t” + “change me”;
String s5=”you can’t”;
String s6=s5+”change me”;
System.out.println(s1==s6); //false
If final String s7=”you can’t”
System.out.println(s1==s7); //true
String s8= s7+”change me”;
s1==s8; //true.
• In our programme., if any String object is repeatedly going to use, we
can keep only one copy in the String Constant Pool and shared by
several required references. Instead of creating several same content
object, we are creating only one object, this is very efficient w.r.t to
memory point of view.
• As several refernces pointing to the same object in the
StringConstantPool, by using any references , if you allowed to use the
content of that object, the remaining references have to suffer.
• Hence once we created a string object we are not allowed to change
content.
• If you want to perform any changes, with those changes a new String
Object wil create . Hence the String Objects are declared as the
Immutable.
• StringConstantPool ---> Performance is improved. (advantages)
----> Immutability ( disadvantages)
Interning Of Strings:
String s1=new String(“viswan”);
String s2=s1;
String s3=s1.intern();
S1==s3; //false
String s4=”viswan”;
s4==s3; //true
• Intern() method used to point the String constant pool object
instead of heap object.
String Class Constructors:
1. String s=new String(String s);
2. String s=new String();
3. String s=new String(StringBuffer s1);
4. StringBuffer s1=new StringBuffer(“xxx”);
5. String s=new String(byte[]);
Ex: byte[] b={100,101,102,102}
String s=new String(b);
System.out.println(s); //”defg”
6. String s=new String(char[]);
Ex: Char[] ch={a,b,cd};
String s=new String(ch);
System.out.println(ch); // abcd
String Class Methods (only some imp):
1. public char charAt(int index):
This method returns the character located at the string’s specified
index. Remember that String indexes are zero based.
2. public String concat(String s):
This method returns a string with the value of the String passed into
the method appended to the end of the String used to invoke the
method.
The overloaded + and += operators perform the same function of
concat() method.
Ex: String s=”durga”;
s=s.concat(“sw”);
s=s+”sw”;
s+=”sw”;
System.out.println(s); //durgasw
3. public Boolean equals IgnoreCase(String s):
This method returns Boolean value ie., true or false depending on
whether the value of the string in the argument is the same as the
value of the String used to invoke the method.
Ex: String s=”DURGA”;
System.out.println(s.equalIgnoreCase(“Durga”); //true
s.equals(“Durga”); //false
4. public int length():
length() is the method in the case of String objects where as ‘length’ is
the variable in the case of Arrays.
Ex: String s= “durga”;
System.out.println(s.length); //CTE
System.out.println(s.length());// 5
5. public String replace(char old, char new):
String x=”ababab”;
System.out.println(x.replace(‘a’,’b’); //bbbbbb
6. a). public String substring(int begin):
String x=”0123456789”;
System.out.println(s.subString(6)); //6789
b). public String substring(int begin, int end):
System.out.println(s.subStrin(5,8)); //567
* End is not included in o/p.

* This is already overloaded method.
* It considers the index only.
String s=”abcdefgh”;
System.out.println(s.subString(3)); //defgh
System.out.println(s.subString(4,7)); //efg
7. public String toUpperCase():
String s= “ A New Moon”;
System.out.println(s.toUpperCase()); // A New Moon
8. public String toLowerCase()
String s= “ A New Moon”;
System.out.println(s.toLowerCase()); // A New Moon
9. public String trim()
String s=”viswan”;
System.out.println(s.trim()); //viswan
---> Leading or trailing blackspaces removed but not in the
middle.
10. public int indexOf(char ch)
---> Returns the index of the first occurance of the specified character.
---> Returns -1, if there is no such character.
String s=”durgascjp”;
s.indexOf(d); //0
11. public int lastIndexOf(char ch)
---> Returns the last occurrence index of the specified character.
String s=”durga”;
String y=s.toUpperCase();
String s=s.toLowerCase();
System.out.println(s==x);//true
System.out.println(s==y); // false
s,x ---> durga y---> durga
• After applying any method of the contest of the String has to change
then only a new String object will create with the corresponding
changes.
Ex1:
String s1=”abc”; s1 ---> abc
String s2=”def”; s2 ---> def <--- s3
String s3=”s2”; s2 ---> ghi
String s2=”ghi”;
S.o.p(s1+s2+s3); //abcghidef
Ex 2:
String x=new String(“xyz”);
y=”abc”;
x=x+y;
total objects are 4 ---> 2 on heap, 2 on string constant pool
* String objects as well as wrapper class objects are immutable.

* String, StringBuffer, wrapper, Math, StringBuilder classes are the final
classes. So, we are not allowed to create the child classes.
StringBuffer , StringBuilder
StringBuffer:
String objects are immutable where as StringBuffer objects are
mutable.
Ex: String s=”viswan”;
s.concat(“sw”); -----> Immutability
System.out.println(s);//viswan
But StringBuffer s=new StringBuffer(“viswan”);

s.append(“sw”); -----> Mutability
System.out.println(s); // viswansw
String s1=new String(“java”);
String s2=new String(“java”);
s1==s2; //false
s1.equals(s2); //false
Because in StringBuffer class .equals() method is not overridden for
content comparision. It is meant for address comparision only.
Constructors Of StringBuffer:
StringBuffer s= new StringBuffer();
Creates an empty StringBuffer object with default initial
capacity 16.
class SBDemo
{
{
StringBuffer s=new StringBuffer();
s.append(“abcdefghijklmnop”);
System.out.println(a.capacity());
}
}
---> If we add q then //34=(16+1)*2
• When ever StringBuffer reaches its max capacity a new
StringBuffer object is created with the new capacity is (current
capacity + 1)*2 ---> (16+1)*2=34
• First time only this can be valid. Afterwards the capacity
increases with the increase of characters only.
StringBuffer sb=new StringBuffer(int initialcapacity)
• Creates an empty StringBuffer object with the specified capacity.
StringBuffer sb=new StringBuffer(String s);
• Creates an equivalent StringBuffer object for the given String and
with a capacity equal to (length of String + 16).
Ex: StringBuffer s=new StringBuffer(“durga”);
System.out.println(s.capacity()); // 5+16=21
Length of the string “durga” =5
important methods of the StringBuffer :

1. public int length() ---> returns the length of the StringBuffer.
2. public int capacity() --->returns the capacity of the StringBuffer
3. public char charAt(int index)
Ex: StringBuffer s=new StringBuffer(“durga”);
char ch= s.charAt(3); //g
char ch=s.charAt(10); //invalid index
i.e., If the index is invalid we will get a RTE saying “String index of
bounds Exception”.
4. public void setCharAt(int index, char ch)
Constructing String from the given StringBuffer Object:
String s= bew String(StringBuffer s)
String s= StringBuffer.toString();
5. public synchronized StringBuffer append(String s); or (int i) or (char
ch) or (float f) or (double d) or (char[] ch) or (Boolean b) or (byte[] b)….
Ex: StringBuffer s= new StringBuffer(“PI”);
s.append(3.14 f);
System.out.println(s); //pi=3.14
6. public synchronized StringBuffer insert(int offset, String s) or
int/char/float/Boolean etc.,
Ex: StringBuffer s= new StringBuffer(“durga”);
s.insert(2,”012”);
System.out.println(s); //du012rga
7. public synchronized StringBuffer delete(int start, int end)
* delete the substring present in start to end – 1 position.

8. public synchronized stringBuffer delete charAt(int index)
* For deleting the character located at specified index.

9. public synchronized StringBuffer reverse()
Ex: StringBuffer sb= new StringBuffer(“madam”);
System.out.println(s.reverse()); //madam
10. public void setLength(int new length)
* This operation can result in the StringBuffer with the specified length.
The Extra characters will be removed.
If the StringBuffer is lessthan the specified length padded or appended

with space characters to the required length.
Ex: StringBuffer s=new StringBuffer(“viswan”);
s.length(3);
System.out.println(s); //vis
Chaining Of Methods :
• In the case of String and StringBuffer, the return type of most of the
methods are String or StringBuffer only, on that return type we are
allowed to call another method, as a result chaining of methods is
possible, in the case of String and StringBuffer.
Ex: StringBuffer sb= new StringBuffer(“durga”);
s1.m1().m2().m3().m4().m5().m6();
* All the method calls will execute left to right.

sb.append(“software”).insert(2,”xxx”).delete(4,7).reverse();
System.out.println(sb); // durgasw
--> duxxxrgasw ---> duxxasw
---> erawtfosaxxud
StringBuilder :
It is exactly similar to StringBuffer except all the methods are
nonsynchronized methods.
When compared with StringBuffer the following are the advantages of
StringBuilder.high performance and the operation are fast.
Data corruption is possible in the StringBuilder which is the major
drawback of StringBuilder, when compared with StringBuffer.
Example:
class Sample
{
{
StringBuilder sb=new StringBuilder(“surya”);
s.append(“software”);
s.reverse();
s.delete(3,5);
}
}
//surya //suryasw
//erawtfosayrces //erafosayrces
Wrapper Class
The Wrapper classes have introduced for the fallowing two purposes by
SUN people.
1. To wrap primitives into object form so that we can handle
primitives also just like objects.
2. We can get several utility functions for primitives.
• The fallowing are the wrapper classes.
Type --------- Class
byte ---------> Byte
short ---------> Short
int ---------> Integer
long ----------> Long
float ----------> Float
double ----------> Double
char ----------> Character
boolean ----------> Boolean
Constructors of the Wrapper classes :

• Integer class contains the fallowing two constructors.
Integer i= new Integer(int i);
Integer i= new Integer(String s);
Ex: Integer i= new Integer(10);
Integer i= new Integer(“10”);
Integer i=new Integer(“ten”); x given
RTE: NumberFormatException
I.e., If the String is unable to convert into a number then we will get a
RTE saying “NumberFormantException”.
---> Byte b=new Byte(byte b);
---> Byte b=new Byte(String s);
Wrapper Class --------- Constructor Arguments
1. Byte --------------------> byte or String
2. Short --------------------> short or String
3. Integer ---------------------> int or String
4. Long ---------------------> long or String
5. Float ---------------------> float or String or double
Ex: float f= new Float(float f); //10.0f //valid
float f= new Float(String s); //”10.0f” //valid
float f= new Float(double d);//10.0 //valid
6. Double ----------------------> double
7. Character ------------------> char
Ex: Character c=new Character(char c);
Character c=new Character(‘d’); //valid
Character c=new Character(“d”); //invalid
8. Boolean ---------------------> Boolean or String
Ex: Boolean b=new Boolean(true); //valid
(false); //valid
(TRUE); //invalid
(FALSE); //invalid
Boolean b=new Boolean(“viswan”); //false
(“yes”); //false
(“no”); //false
Note: Other than “true” everything should return ‘false’.
Which of the fallowing are valid Boolean declarations?
1. boolean b=true; //valid
2. boolean b=false; //valid
3. boolean b=TRUE; //invalid
4. boolean b=FALSE; //invalid
5. Boolean b=new Boolean(“true”); //valid
6. Boolean b=new Boolean(“false”); //valid
7. Boolean b=new Boolean(“yes”); //valid //false
8. Boolean b=new Boolean(“NO”); //valid // false
9. boolean b=yes; //invalid //Compile time error
10. boolean b=NO; //invalid // Compiletime error
valueOf() method:
• Except character class every wrapper class contain a static valueOf()
which can be used for converting a String object to corresponding
wrapper object.
Ex: Integer i=Integer.valueOf(“10”); //valid
Integer i=Integer.valueOf(“ten”); //invalid // RTE
:NumberFormatException
Boolean b= Boolen.valueOf(“xxx”); //false
valueOf(String):
String object ----------to------------> Wrapper Object
• This is a static method.
• The argument is String only.
• Throws NumberFormatException, if we are unable to convert the
String to number.
Ex: Integer i= Integer.valueOf(10); //invalid
Argument is not String ,the Second version of valueOf() method:
• Byte. Short, Integer, Long classes contain second version of valueOf()
method which can take a String and radix as arguments.
• First the String converted into decimal form and then that decimal
value will be stored in the wrapper object.
Ex1: Integer i=Integer.valueOf(”101100”,2) ;
System.out.println(i);//44 base=radix
Signatures:
1. public static wrapper valueOf(String s)
object
2. public static wrapper valueOf(String s, int radix)
object
Ex2: Long l=Long.valueOf(“12”,5);
System.out.println(l); //7
* totally “36” bases or radixes are valid
xxxValue() methods:-
• All the numeric wrapper classes contains the fallowing methods for
“converting wrapperclass object to primitive”.
intVlaue(); byteVlaue(); shortVlaue(); longVlaue(); floatVlaue();
doubleVlaue();
• Each wrapper class contains the above six methods, in total 36
xxxValue() methods are possible.
• These xxxValue() methods are instance methods and no arg
methods.
Ex: Double d =new(150,263);
System.out.println(d.byteValue()); // -106
System.out.println(d.shortValue()); //150
System.out.println(d.intValue()); //150
System.out.println(d.longValue()); // 150
System.out.println(d.floatValue()); // 150.263
System.out.println(d.doubleValue()); // 150.263
• Character class contains charValue() method for converting character

object to primitive.
Ex: Character ch= new Character(‘a’) ;
Char c=ch.charValue();
System.out.println(c); // a
• Boolean class contain booleaValue() method for converting a Boolean
object to Boolean primitive.
Ex: Boolean B=new Boolen(“viswan”);
boolean b=B.charValue();
System.out.println(b); //false
parseXxx() methods:
• Every wrapper class except Character class contain parseXxx() for

converting a String object to corresponding primitive.
Ex: String s=”10”;
int i=Integer.parseInt(s);
double d=Double.parseDouble(s); //10.0
long l=Long.parseLong(s);
Wrapperclass--------- parseXxx()
Byte ------------> parseByte(String s)
Short -------------> parseShort(String s)
Integer -------------> parseInt(String s)
Long -------------> parseLong(String s)
Float -----------> parseFloat(String s)
Double ------------> parseDouble(String s)
• Boolean class contain a static method getBoolean() method for
converting a string to Boolean primitive.. -----> 1.4 version
String s=”123”;
int i=Integer.parseInt(s);
double d=Double.parseDouble(s);
System.out.println(i); //123
System.out.println(d); //123.0
Boolean b=getBoolean(“viswan”);
System.out.println(b); //false
Second version of parseXxx() :-
• All the integral wrapper classes (byte, short, integer, long) contains
second version of parseXxx().
public static primitive parseXxx(String s,int radix)
Ex: int i=Integer.parseInt(“10101100”,2);
System.out.println(i); //172
long l=Long.parseLong(“12”,8);
System.out.println(l); //10
• java support max – radix is 36(base)
System.out.println(Character.MAX-RADIX); //036
toString() method:
1st version:-
• All the wrapper classes contains an instance toString() method for
converting wrapper class object to corresponding String object.
• public String toString();
Integer i=new Integer(10);
String s= i.toString();
System.out.println(s); // 10
Boolen B=new Boolean(“surya”);
String s=B.toString();
System.out.println(s);//false
2nd Version:
• Every wrapper class contain a static toString() method for converting

a primitive to String object.
• This is available in all wrapper classes and object class also includes
Boolean and Character classes.
• public static String toString(10);
Ex: String s1=Integer.toString(10);
String s1=Boolean.toString(true);
String s1=Integer.toString(‘a’);
3rd Version:
• Integer and Long classes contain the 3rd version of the toString()
method for converting given primitive to String of sprcified radix.
• public satic String toString(30,2);
Ex: String s= Integer.toString(30,2);
System.out.println(s); //”11110”
toString(primitive, int radix)
4th version:
• public static String to xxxString(primitive) //int/long
• The version of toString() is available in the Integer and Long classes
only. The possible to xxxString() methods are, toBinaryString,
toHexString and tooctalString for converting the given primitive to the
corresponding String form.
String s=Integr.toBinaryString(100); //1100100
String s=Integr.toOctalString(100); //144
String s=Integr.toHexString(100); //64
• All the wrapper class objects are immutable and all the wrapper
classes are final classes.
• ‘void’ is also one type of wrapper class.
• String class and all the wrapper classes are immutable.
• The fallowing are the final classes.
-->String
--> StrringBuffer
--->Math
AutoBoxing , AutoUnBoxing
AutoBoxing:
• Automatic conversion by the compiler from primitive type to the
corresponding object form is called AutoBoxing.
Ex: int i=10; //Compile time error in 1.4 but valid in 1.5
Integer I=i;
• Compiler first constructs the integer object and then assigned that
object to the variable.
AutoUnBoxing:
• Automatic conversion from wrapper class object to primitive type by
the compiler is called AutoUnBoxing.
Ex: Integer I= new Integer(10);
int i= I; //CTE :1.4
// valid in 1.5
* The compiler coverts Integer object to primitive and that primitive

value will assign to variable i.
* Because of these new autuboxing or auto unboxing features, the

importance of wrapper classes is not that much in the 1.5 version.
AutoBoxing in expressions:
Integer y=10;
Integer x=y;
Y++;
System.out.println(x); // 10
System.out.println(y); // 11
System.out.println(x==y); // flase
Wapper class objects are immutable .if you want to perform any
changes with those changes a new wrapper class object will create.
Special cases:
case1:
System.out.println(i1==i2); //false
Case2:
Integer i2=10;
Case3:
Integer i1=100;
Integer i2=100;
System.out.println(i1==i2); //true
Case4:
Integer i1=1000;
Integer i2=1000;
In the case of autoboxing compalier won’t create any new object If an
existing already created object mapped with the reqired one . the
existing object should be created bt the autoboxing only.
This poosibility will occur in the following cases.
1.By using autoboxing. If it is required to create a new wrapper object,
other wise compiler won’t create any new object, if already an object is
present in the fallowing cases. these Objects are Boolean and Byte.
2. Character object ranges from 0 to 127 ------> (‘\u0000’ to ‘\u0007f’).
3. For the integer and short if the value is less than or equal to 127.
4. For the long of the value is less than or equal to 127 L .
But Long l=10; //invalid
CTE: incompatable types
Found:int , req: java.lang.Long
Similarly Float f= 10; //invalid - CTE: incompatable types
Found: int, req: java.lang.Float
Case5:
Boolean b1=true;
Boolean b2=true;
System.out.println(b1==b2); // true
Case6:
Boolean b3=flase;
Boolean b4=flase;
System.out.println(b3==b4); // true
Special case:
Example:
class Sample
{
static Integer I1=10; ---->I1: Initialized
{
m1(I1); ---> I1 : auto unboxing
}
public static void m1(int i)
{
Integer I2=i; ----> I2: auto boxing
System.out.println(I2); //10
}
}
above example executes fine.
But
class Sample
{
static Integer I1; // not Initialized
{
m1(I1); // null pointer exception
}
public static void m1(int i)
{
Integer I2=i;
System.out.println(I2);
}
}
Static variables by default initialized with null, which can’t be
autoboxing/autounboxing.Hence Run time exception.
overloading when combining with widening and Autoboxing:

class Text
{
static void m1(Integer x)
{
System.out.println(“integer”);
}
static void m1(long l)
{
System.out.println(“long”);
}
{
int i=5;
m1(i); //long
}
}
when comparing widening with autoboxing compiler always prefers
widening in order to provide the sport for legacy code.
Over loading in case of widening with var-arg method:
Class sample
{
static void m1(int I,int j)
{
System.out.println(“int, int”);
}
static void m1(byte… b)
{
System.out.println(“byte arg”);
}
{
byte b=5;
m1(b,b);
}
} // in tint
widening dominates var-arg method .compiler will give the precedence
for widening over var-arg method.
Autoboxing vs var-args:
Class Sample
{
static void m1(Byte b)
{
System.out.println(“byte”);
}
{
System.out.println(“byte arg”);
}
{
byte b=5;
m1(b);
}
}
the compiler prefers autoboxing over var-args
If there is no other method matched,then only var-arg method always
seeks to least priority.
Conclusion:
The compiler always gives the precedence in the following order for
resolving over loading methods.
1.wid4ening
2.auto boxing & unboxing
3.var- args
Special cases:
Class Sampe
{
public static void m1(Long l)
{
System.out.println(“long”);
}
{
byte b=5;
m1(b);
}
}
In java widening followed by autoboxing is not allowed.Hence the

above code raise a CTE saying m1(java.lang.long) in sample can not be
applied to (byte).
i.e Byte --------> Long is not possible.
But byte ----->long is possible.
Widening followed by autoboxing is not allowed. But the reverse is
allowed in java i.e autoboxing follwed by widening is possible.
Class Sample
{
static void m1(Object o)
{
System.out.println(“object”);
}
{
byte b=5;
m1(b); // object
}
}
i.e byte -----> Byte -----> Object
i.e Here autoboxing is followed by widening .
class Samle
{
{
System.out.println(“byte……”);
}
static void m1(byte b,byte… b1)
{
System.out.println(“byte, byte….”);
}
{
byte b=5;
m1(b); // CTE saying reference to m1 is ambiguous.
}
}
Here both methods are matched because of var-args feature.Hence
compailer can’t give any precedence results in CTE
Static variable by default initialized with null,which can’t be autoboxing
/autounboxing
enum
It defines a list of named constants.This is interdused in 1.5
version.
Java enum is powerful than c,c++ enums because java enum
may contain methods ,constructors and instance variables in
addition to constants.But c,c++ enum contain only constants.
Example:
enum Month
{
Jan,Feb,Mar,Apr…….;
}
Example:
enum Beer
{
KF,RC,H5,H2,…….;
}
No variables in enum.At the end ( ; ) no need to specify (optional)
Use:we can reduce the number of bugs by using enumeration because
We are providing a set of predefined values for the variables.
Enum Example code:
enum Month
{
Jan,Feb,Mar,Apr;
}
class Sample
{
{
Month m=Month.Mar;
System.out.println(m); // Mar
}
}
We can keep enum outside the class or inside the class.If we are
declaring enum outside the class,the allowed modifiers are public
,<default>.we can declare enum with in a class the allowed modifiers
are public ,<default>,protected,private.
We never allowed to declare enum inside a method,violation
leads to compile time error saying enum type must not be local.
Enum types is allowed to used as argument for the switch statement.
Example:
Enum Beer
{
KF,RC,H5;
}
class Sample
{
{
Beer b= Beer.KF;
Switch(b)
{
case KF:
System.out.println(“too Bitter”);
break;
case RC:
System.out.println(“too Hot”);
break;
case H5:
System.out.println(“too strong”);
break;
}
}
}
until 1.4 version the allowed arguments for the switch statement are
byte,short,int,char.But 1.5 version onwords in addition to these
arguments Byte,Short,Character,Integer and enum also.
Values() method:
Enum contains a predefined method values to list the constants
available in that enum.
Example :
enum Month
{
Jan,Feb,Mar,Apr;
}
class Client
{
{
Month[] m=Month.values();
for(Month m1:m)
{
System.out.println(m1); // Jan,Feb,Mar,Apr
}
}
enum never participated in inheritance hierarchy because every
enum class implicitly extends java.lang .enum .Thats why we never
allowed to create a child classfor the enum.As Month enum already
extends java.lang.enum hence it never allowed to extend any other.
Enum Month extends Some ---> not possible
If we are writing any enum it is extending java.lang.enum class.Hence
it never extends any thing else.So inheritance concept not applicable
for enums.
Example:
Enum Beer
{
KF(65),RC(50),H5(100),KO;
int price;
Beer(int price)
{
this.price=price;
}
public int getPrice()
{
return price;
}
Beer()
{
this.price=100;
}
}
class Sample
{
{
Beer b=Beer.KF;
System.out.println(b); //KF
System.out.println(Beer.KF.ordinal());
System.out.println(b.price); //65
System.out.println(b.getPrice()); //65
Beer[] s=Beer.values();
for(Beer s1:s)
{
System.out.println(s1+”……….”+s1.getPrice());
}
}
}
• When ever enum is loaded into the memory, all the enum
constants will be assigned and JVM calls Constructor
automatically. The programmer is not allowed to call enum
constructor explicitly.
• The Constructors of enum can be overloaded if the enum
contain both enum constants, instance variables, the first line
should be enum constants and ends with semicolon.
i.e.
enum Beer
{
KF, RC //invalid ; missing
int price;
}
enum Beer
{
int price; //invalid because the 1st stmt should be enum constants.
KF, RC;
}
enum Beer
{
KF, RC;
int price; //valid
}
Ordinal Value
• The position of enum constant is important and indicated by their
ordinal values. We can ordinal value for any enum constant by the
fallowing method.
Public final int ordinal();

Ordinal value starts from zero(0).
Enum Month
{
JAN,FEB;
{
Month[] m=Month.values();
for(Month m1:m)
System.out.println(m1);//JAN,FEB
}
}//Save:Month.java, Run:Java Month
So just like a normal class, we can run enum also.
System.out.println(Month.JAN==Month.FEB); //false
So we can compare the constants declared in enum. Otherthan ‘=
=’operators, remaining <=, >=,<,> will gave CTE.
Duplicate constants can’t be declared. So, constants are unique.
enum Month
{
Jan,Feb,Jan; //invalid,CTE:Jan already defined
}
But
enum Month
{
Jan,Feb,JAN; //valid, due to case sensitive jan!=JAN
}
Comparable Interface and clonable interface
Comparable Interface:
This is present in java.lang.package
Contains the following one method.
1.public int compareTo(Object o)
if returns –ve integer if o1 has to place before o2.
If returns +ve integer if o1 has to to place after o2.
If returns zero then o1 and o2 are equal.
All the wrapper classes and string class already implemented
comparable interface. But the StringBuffer doesn’t implement
comparable interface.
Comparable Interface Example:
Interface comparable
{
public int compareTo(Object o)
{
TreeSet t=new TreeSet(0;
t.add(“a”);
t.add(‘z”);
System.out.println(t); // a,z (:: z.compareTo(“a”);)
System.out.println((“a”).compareTo(“z”)); //-25
System.out.println((new Integer(10).compareTo(new Intege(1)); // +1
}
}|
Marker or Tag Interface:
If an interface is marked for some ability such type of interfaces are
called Marker interfaces.
Ex: clonable,serializable
If an interface with out any method obviously accept ass marker
interface.
Eventhough interface contains some methods,still we can consider as
marker interface .If it is marked for some ability.
Ex:Comparable interface.
Intreger i1=new Integer(10);
System.out.println(i2.compareTo i1); // -1
System.out.println(i1.compareTo i2); // +1
System.out.println(i1.compareTo i1); // 0
System.out.println(i1.compareTo(“a”)); // CTE nullpointer exception
Cloneable interface:
Uptaining exact copy of a plant ,a bird,an animal or a human being is
called cloning.
Cloning in programming uptaining bit wist exact copy of an object is
called cloning.
cloning Example:
Class sample() implements cloneable

{
Int i=10;
Public static void main(string args[])throwsClone
notSupportedEexception
{
Sample s1=new sample();
Sample s2=s1;
Sample s3=(sample)s1.clone();
S1.i=1000;
System.out.println(s3.i);
we should type cast otherwise
CTE:in compatable types
Found: Object reqired=sample
The class must implements cloneable interface otherwise at runtime
clone() results cloneNotsupportException
Example:
Class sample implements clonable
{
Int i=10;
Public static void main(string[]args)throws cloneNot support Exception
{
Object o=new object();
Object o2=o.clone();
}
CTE:clone() has protected access in java.lang.object
The protected numbers we can access, from with in the same package
or from outside package but from outside package,the protected
number can be accessed b using child class reference only.ie we can’t
use parentclass reference to access protected number from outside
package,validation leadsto CTE.
clone() method:
object..
An object is said to be conable if and only if the corresponding class
implements clonable interface.
By using the folling object class clone() method we can produced
cloned objects
Shallow cloning Example:
{
String name;
String age;
Student(String name,String age)
{
This.name;
This.age=age;
]
Public Object clone()throws cloneNotSupportedException
{
Return this;
}
}
Class Student cloneDemo
{
Student s1= new Student(“hai”,”22”);
Student s2= (Student)s1.clone();
S2.name=”abc”;
Public static void main (String ar[])
{
StudentCloneDemo s1= new Student cloneDemo();
}
}
Deep cloning example:
{
String name;
String age;
}
Student(String name ,String age)
{
This.name=name;
This.age=age;
}
Public Object clone(0throws CloneNotSuport Exception

{
try
{
ByteArrayOutputStream bas=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bas);
Oos.writeObject(this);
ByteArrayInputStream bias=new
ByteArrayInputStream(bas.toByteArray());
ObjectInputStream oos=new ObjectInputStream(bias);
Return ois.readObject();
}
catch(Exception e)
{
return null;
}
}
class DcloneDemo
{
DcloneDemo()throws CloneNotSuportException
{
Student s1=new Student(“hello”,”200”);
Student s2=(Student)s1.clone();
S2.name=”java”;
Public static void main(String[] arg)
{
new DcloneDemo();
}
}
Java DefaultExceptionHandler
An Exception is an abnormal and unexpected and also unwanted event
that disturbs the normal flow of the program.
Ex: FileNotFoundExceptionArithmaticException etc..
Default Exception Handling Mechanism in JAVA:
class Sample
{
{
doStuff();
}
public static void doStuff()
{
doMoreStuff();
}
public static void doMoreStuff()
{
System.out.println(10/0);
}
}
RTE: Exception in thread “main” Java.Lang.Arithematic Exception: /by

zero
At Sample . doMoreStuff(Sample.java)
At Sample . doStuff(Sample.java:9)
At sample . main(Sample. java :5)
• If an exception is raised inside any method is r3esponsible for the
creation of exception object. (here doMoreStuff() is responsible )
• The Exception object must contain the fallowing information.
1. Name of the Exception(Java.Lang.ArithematicException)
2. Description of the Exception (/ by zero)
3. The position at which the exception raised. (stack trace).
• Now the method handover that exception object to the JVM. JVM will
come with that exception object and it will check, is there any
exception object and it will check is there any exception handler inside
that method abnormally and removes the corresponding entry from
the stack.
• Now the method handover that exception object to the JVM. JVM will
come with that exception object and it will check, is that any exception
handler inside that method. If there is no exception handler then JVM
blindly terminate that method abnormally and removes the
corresponding entry from the stack.
• JVM will check for the caller(doStuff()) containing any exception
handling code. If the caller also doesn’t contain any exception handling
code, then JVM simply terminate that method also and remove the
corresponding entry from the stack.
• This process will continue, until main() method. If the main() also
doesn’t have any exception handling code then JVM terminates main()
abnormally and handover the responsibility of the exception handling
to default exception handler.
• Now Default Exception handler print the exception
information to the end user
CommonExceptions and Errors:
Exceptions or errors may be thrown by either JVM(JVM Exceptions) or
thrown explicitly by application developers or API
programmers(programmatic exception).
1. NULLPOINTER EXCEPTION:
Class Sample
{
Static int[] a;
Static String name;
{
System.out.println(a.length);
}
}
System.out.println(a[o]); // null pointer exception (NPE)
System.out.println(name.length); //NPE
This is child class of RuntimeException. It is unchecked exception.
This is thrown by JVM when attempting to acess an object with a
reference variable whose current value is null.
Ie., on null if we are applying any operation we will get
NullPointerException.
2. STACK OVERFLOW ERROR:-
• This is child class of virtual machine error.
• It is unchecked
Throwable ----> Error ---> VMError ---> StackOverFlowError
Ex:class Sample
{
public static void m1()
{
m1();
}
public static void main(String a[]){ m1(); } // stack overflow error
}
StackOverflow error is thrown by JVM when a method recurses too
deeply.
class Sample
{
Sample() { new Sample(); }
public static void main(String a[]) { Sample s= new
Sample(); }//Exception in main thread stack overflow error
}
3. ARRAY INDEXOUTOF BOUNDS EXCEPTION:
• This is a child class of IndexOutOfBoundsExcption.
Throwable ---> Exception ---> RunTimeException ---->
IndexOutOfBoundsException---> ArrayIndexOutOfBoundsException,
StingIndexOutOfBoundsException
• It is an unchecked exception thrown by JVM when we are accessing
an array element with
Invalid index.
Ex:
class Sample
{
{
Int[] a=new int[6];
System.out.println(a[5]); //0
System.out.println(a[7]); //RTE: ArrayIndexOutOfException
System.out.println(a[-2]); //----do----
System.out.println(a[-2.5]); //CTE: PLP req: int found:double
}
}
4. CLASS CAST EXCEPTION:
Class Sample
{
public static void main(String a[]))
{
String s=”anu”;
Object o=(Object)s;
String s1=(String)O;
}
}
• It is the child class of RTE
• It is unchecked exception, thrown by JVM when attempting to cast a
reference variable to a type the fails to cast a reference variable to a
type the faith the IS- A test.
----> Object o=new Object();
String s=(String)o; // Class Cast Exception
----> StringBuffer s1= (StringBuffer)s;
5. NOCLASS DEF FOUND ERROR:

It is the child class of error and it is unchecked one and unreachable.
It is thrown by JVM. If the JVM or class loader tries to load the definition
of the class and no definition of the class could be found.
6. EXCEPTION IN INITIALIZER ERROR:
class Sample
{
Static String s;
String s1=new String(s);
{
}
}//Exception in initializer error caused by
java.lang.NullPointerException.
Thrown by the JVM to indicate that an exception is occur during
initialization of static variable or initialization block.
7. ILLEGAL ARGUMENT EXCEPTION:
It extends RTE and unchecked.
Thrown by aPI developer to indicate that a method has been passed an
illegal or inappropriate argument.
Ex: Thread class setPriority() and sleep() methods throw this exception.
class Sample
{
p s v m(String a[])
{
Thread.currentThread().setPriority(15);
}
}//CTE: Illegal Argument exception
8. NumberFormatException:
Integer i=new Integer(“10”);//valid
Integer i=new Integer(“ten”);//invalid
CTE: NumberFormateException
int i=Integer.parseInt(arg[0]);
In commandline if we give “10” is valid. But “ten” is invalid.
It is the direct child class of illegal argument exception and thrown
programmatically to indicate the application has attempted to convert
a string to the number, but the string doesn’t have appropriate format.
9. IllegalStateException:
It extends RTE and indicates that a method has been invoked at an
illegal or inappropriate time.
Ex: PrintWriter out=res.getWriter();
Out.println(…);
Out.close();
Out.println(“…”); ---> this is not appropriate time to call print() on out
object and hence throws IllegalStateException.
10. Assertion Error:
It is the child class of error throws programatically when assert
statement when Assert statement fails.
Summarization:
Exception or error --------------------- thrown by
1. NullPointerException ------------------ JVM
2. StackOverFlowErrorException --------------- JVM
3. ArrayIndexOutOfBoundsException ------------- JVM
4. ClassCastException ------------------------- JVM
5. NoClassDefFoundError -------------------- JVM
6. ExceptionInIntializerError -------------------- JVM
thrown by programmatically by programmer API developer:

7. IllegealArgumentException
8. NumberFormatException
9. IllegalStateException
10. Assertion Error
Checked , Unchecked Exceptions
Checked vs Unchecked Exceptions :
• The Exceptions which are checked by the compiler for
smooth execution of program at Runtime are called checked
Exceptions.
• The Exceptions which are unable to check by the compiler
are called Unchecked Exceptions.
• Runtime Exception and its child classes: Error and its child classes
are Unchecked Exceptions. While the remaining all are Unchecked
Exceptions.
P
artially Checked vs Fully Checked :
A Checked Exception is said to be Fully Checked Exception if
and only if all its child classes are also checked. Otherwise it is
Partially Checked Exception.
Ex: IOException is Fully Checked Exception
Exception is Partially Checked
Throwable is Partially Checked
try , catch , finally
finally block:
try
{
System.out.println(10/0);
}
catch(AE e)
{
System.out.println(“catch”);
}
finally
{
}
• The cleanup code, we have to keep inside finally block because
irrespective of exception occurred or not occurred or handled or not
handled, the finally block will always execute.
Q: Difference between final, finally and finalize?

• It is highly recommended to keep cleanup code inside finally block
instead of finalize().
• The finally block will always execute except the place where
the JVM got shutdown. We can shutdown the JVM by calling
/using System.exit(0).
Example:
try
{
}
catch( NULL pointer exception e)
{
}
finally
{
System.out.println(“finally”);
}
output:
hai
finally
Samples:
1. try{} catch(X e){} -->valid
2. try{}catch(X e){}finally{} -->valid
3. try{}finally{}catch(X e){} --> invalid
4. try{}finally{} -->valid
i.e , try --> catch --> finally is the only order.
Only try{} ---> invalid,
Only catch{} ----> invalid
Only finally{} ----> invalid
Note: try without catch & catch with out try invalid
Example:
catch(..){}
finally{}
CTE: catch with out try
Control Flow in try, catch, finally block :

try
{
Stmt1;
Stmt2;
Stmt3;
}
catch(XException e)
{
Stmt 4;
}
finally
{
Stmt 5;
}
Stmt 6;
See the below cases:

Case 1:- If there is no exception then 1,2,3,5,6 and normal termination.
Case 2:- If an exception raised at stmt2 and the corresponding catch
block found 1,4,5,6 and normal termination.
Case 3:- If an exception raised at stmt2 and the corresponding catch
block not matched 1,5 and abnormal termination.
Control Floe in the Nested try, catch, finally blocks:

try
{
Stmt1;
Stmt2;
Stmt3;
try
{
Stmt4;
Stmt5;
Stmt6;
catch(XException e)
{
Stmt 7;
}
finally
{
Stmt 8;
}
Stmt 9;
}
catch(YException e)
{
Stmt 10;
}
finally
{
Stmt 11;
}
Stmt 12;
Case 1: If there is no exception 1,2,3,4,5,6,8,9,11,12 and normal

termination.
Case 2: If an exception raised at stmt 2 and the corresponding catch
block found then 1,10,11,12 and normal termination.
Case 3: If an exception raised at stmt2 and the corresponding catch
block has not matched then 1,11 and abnormal termination.
block has matched then 1,2,3,4,7,8,9,11,12 and normal termination.
block has not matched but the outer catch has matched then
1,2,3,4,8,10,11,12 and normal termination.
Case 6: If an exception raised at stmt5 but the inner and outer catch
blocks are not matched then 1,2,3,4,8,11 and abnormal termination.
‘Throw’ keyword:
{
try
{
Throw new AithmeticException()
}
}
By using ‘throw ‘ keyword, over created customized exception objects
are handed over to JVM.
Example:
class Sample
{
{
throw new ArithmeticException();
}// CTE: Unreachable statement
}
After throw we are not allowed to keep any statement, violation leads
to CTE saying “unreachable statement”.
Example:
class Sample
{
static ArithmeticException e;
public static void main(String[] a)
{
throw e; //invalid
}
}
output: NullPointerException
‘e’(is in instance area) is not pointing “ArithmeticException’ here.
static ArithmeticException e=new ArithmeticException();
Example:
class Sample
{
{
Throw new Exception(); //invalid
}
}//CTE: “Unreported Exception Java.lang.Exception must be caught” or
declared to be thrown.
• Inside a program if there is any chance of throwing a checked
exception explicitly or implicitly we have to handle that checked
exception by using try - catch or we have to delegate the responsibility
or exception handling to the caller. Violation leads to CTE saying
Unreported Exception xxx; must be caught or declared to be thrown.
throws , throw
“throws” Keyword :We can ‘throws’ keyword for delegating
the responsibility of the Exception handling to the caller.
Ex:
class Sample
{
public static void main(String a[])throws InteruptedException
{
doStuff();
}
public static void doStuff()throws IE
{
doMoreStuff();
}
public static void doMoreStuff()
{
Thread.sleep(1000);
}
}
without ‘throws’ CTE: Unreported Exception
java.lang.interuptedException ; must be caught or declared to be
thrown. To avoid CTE(compile time error) another way in using try --->
catch block.
Ex:
class Sample
{
{
try
{
}
catch(IOException e){} --->CTE (fullychecked exception)
}
}
CTE: exception java.io.IOException is never thrown in the body of the
corresponding try statement.
If we are keeping the catch block for fully checked exception there
should may be a chance of raising exception in the corresponding try
block otherwise CTE saying XXXException is never thrown in the body
of corresponding try statement.
Case 1:
try
{
}
catch(ArithematicException e) //valid no CTE(compile time error)
{ //unchecked exception }
Case 2: try
{
}
catch(Exception e) //valid no CTE
{
//Partially checked exception
}
Case 3:
try
{
}
catch(IOException e) //invalid CTE
{
// fully checked exception
}
Throw keyword:By using ‘throw ‘ keyword, over created

customized exception objects are handed over to JVM.
Example:
class Sample
{
{
throw new ArithmeticException();
}// CTE: Unreachable statement
}
After throw we are not allowed to keep any statement, violation leads
to CTE saying “unreachable statement”.
Customized Exceptions :
Based on the programming required sometimes we have to design our
own Customized Exceptions.
Ex: Insufficient funds Exception
too young Exception
too old Exception
throw Example:
class TooYoungException extends RunTimeException
{
TooYoungException(String s)
{
super(s);
}
class Sample
{
{
int i=Integer.parseInt(arg[0]);
if(i>85)
throw new TooYoungException(“please wait some more time, you eill
get married”);
else if(i<10)
throw new TooYoungException(“ur age is already crossed”);
else
throw new TooYoungException(“very soon you will get match”);
}
}
java File
File:
A File Object is an abstract representstion of name of a file or
directory.
File f=new File(“abc.txt”);

Ststem.out.println(f.exits()); ------------>output: false
F represents a file abc.txt only
File f=new File(“Laxman”);
F represents a diretory ‘Laxman’.
.java file object represents both files and diretory(unix terminology).
Constructors of the File class:

--> File f=new File (String name)
create a file instance that represents the name of the file or directory.
--> File f =new File(String diretory,string name)
creates a file instance that represents a diretory or file name in the
specified directory.
---> File f=new File(File dir,String name)
create a new file instance that represents a file or diretory name in the
specified directory.
If the specified is not exists we will find an exception saying
IOException system can’t find the specified diretory.
Methods of the File class:
1.boolean exists()
return true if the file or diretory exists,otherwise false.
2.boolean createNewFile()
returns true if it will create a new file otherwise false.
3.boolean mkdir()
create the new diretory and returns true if the directory already
present returns false.
4.boolean isFile()
return true if the file object represents File
5.boolean isDirectory()
Inorder to check whether the file object represents,physical file name
or directory.
6.String[] list()
returns the files/directory name present in the directory.
7.boolean delete()
delete the file or directory represented by file object.
8.boolean renameTo(File destination)
1)Write a program(WAP) to create a file named with “xyz.txt” in the
current directory.
2)WAP for createing a directory laxman123 in the current working
directory and in that create a file named with file1.txt.
3.WAP a program to list all the files and directories present in directory
laxman123.
File Example :
1. Class Sample
{
public static void main(String add[])
{
File f=new File(“xyz.txt”);
If (!f.exists())
f.createNewFile();
System.out.println(f.exists());
}
}
2. class Sample
{
public static void main(String aff[])
{
File f=new File(“laxman.txt”);
If(!f.exists())
f.mkdir();
File f1=new File(“laxman”,”laxman txt”);
F1.createNewFile();
System.out.println(f1.exists());
}
}
3. Class Samle
{
public static void main(String ah[])
{
File f=new File (“laxman123”); ------------->already exists
String[] s=f.list();
for(String s1:s)
{
}
}
With the same name there may be a chance of a file or a directory
.From java code creating the file followed by creating the directory
with the same name allowed and File object represents a file only.
After creating the directory ,if we are creating file with tha same name
we will get RTE saying IOException:Access is denied
File f=new File(“dir1”,”file1.txt”);
This file object represents a file named with file1.txt which will present
in the directory
f.writeNewFile();
If the directory is not present then f.createNewFile() results a RTE
saying IOException:The system can not find the path specified.
If we call list() method on java file object which represents a physical
file instead of directory.it just simply return null.
If applied on directory it returns the content of the directory.
java All Reader classes
FileReader class:
If is the child class of abstract class reader this can be used for reading
charater data from a file.
FileReader Constructors:
1.FileReader fr=new FileReader(String fname)
2.FileReader fr=new FileReader (Filename f)
if the file is not found these constructors raise RTE saying FileNotFound
Exception
Methods:
1. int read()throws IOException
return the Unicode of the next charater if it is exists else---1.
2.int read(char[] ch)
returns the number of charaters from the file and populated in the
specified array.
3.void close()
the flushing is not reqired while reading data .so MISSING
File Reader Examples:
FileReader fr=new FileReader(“laxman.txt”);
System.out.println(“fr.read());
Char[] ch =new char[200];
Fr.read(ch);
For(char c1:ch)
System.out.println(c1);
Fr.close();
BufferedReader:
By using this we can improve the performance.It contain a separate
method readLine() to read single line at a time instead of
single charater.
So this is the more convenient class for reading charater data from a
file
Constructors:
1.BufferedReader br=new BufferedReader(Reader r)
2.BufferedReader br=new BufferedReader(Reader r,int size)
Methods:
1.int read()throws IOException
to read a single character
2.int read(char[] ch)throws IOException
to read an array of character
3.String readLine()
to read nextline a single line.
If there is no next line return null
BufferedReader Example:
FileReader fr=new FileReader(“laxman.txt”);
BufferedReader br=new BufferedReader(fr);
String s=br.readLine();
While(s!=null)
{
S=br.readLine();
}
br.close();
}
java All writer classes
FileWriter:
This is a child class of writer .this class can be used for writing charater
data.
FileWriter constructors:
1.FileWriter fw=new FileWriter(Filename)
create a filewriter object to the given file if the file having this name
,doesn’t exists this constructor automatically creates the
corresponding file also.But this is not possible in the case of File
constructor.
2.FileWriter fw=new FileWriter(File f)
create FileWriter object for the specified File f .if the file is not already
present this constructor wilol create automatically the file also.
3.FileWriter fw=new FileWriter(String file name,Boolean
append)
If the second argument is true the data append to the existing
content .If it is false ,then the old data is over ridden by new data.
4.FileWriter fw =new FileWriter (File f, boolean append)
------>By default flase.
Methods of FileWriter:
1.void write(int ch)throws IOException
the Corresponding character can be written to the file.
2.void write(String s)throws IOException
writes a String to the file
3.void write(char[] ch)throws IOException
writes a charater array data ti the file
4.void flush()
to guarented that the last character of the data should be written to
the file
5.void close()
To the close file writer object
6.void write(int unicodevalue)throws IOException
File writer Example:
Import java.io.*;
Class Sample
{
public static void main(String aff[])
{
File f=new File(“file1.txt”);
FileWriter fw =new FileWriter(f);
Fw.write(100);
Fw.write(“laxman software”);
Char[] ch={‘L’,’a’,’x’,’m’,’a’,’n’};
Fw.write(ch);
Fw.close();
Fw.flush();
}
}
while inserting the data ,the programmer is responsible to insert
separately the line separator(\n).
When we are reading the data ,we have to put inside the char array.
we should know the size of the array in advance otherwise it will be a
probleam .
we have to read the data charater by charater which increase the
number of IO operations and decreses the performance of the system.
To overcome this ,SUN people has introduced buffered reader and
bufferwriter class
BufferedWriter:
we can create a bufferedwriter object over any writer object.
Construtors:
BufferedWriter bf=new BufferedWriter(Writer w);
BufferedWriter bw=new BufferedWriter(Writer w,int size);
Where size is the size of the buffer
Methods:
1.void write(int i)throws IOException
To write one charater
2.void write(String s)throws IOException
to write the given string
3.void write(char[] ch)throws IOException
4.void newLine()
to insert a new line character
5.void flush()
6.void close()
Q.when compare with java.io.BufferedWriter to java.io.FileWriter which
capability exists as a method in only one of .
a.closing system
2b.flushing the stream
c.writng to the stream
d.marking the location in the stream
e.writing the line separator to the string (valid)
Buffered Writer Example:
Class Sample
{
public static void main(String args[])
{
FileWriter fw=new FileWriter(“laxman.txt”);
BufferedWriter bw=new BufferedWriter(fw);
Bw.write(100);
Bw.write(“laxman”);
Bw..newLine();
Bw.write(“scjp”);
Bw.newLinw();
Bw.write(“srnagar”);
Bw.flush();
Bw.close();
Fw.close();
}
}
When ever we are closing the BufferedWriter autpmaticaly the stream

opened by fileWriter is also closed.
PrintWriter:
The most convenient class for writing any kind of text data .It has
enhanced in 1.5 version.
Constructors:
1.PrintWriter p=new PrintWriter(String name)
2.PrintWriter p=new PrintWriter(File name)
3.PrintWriter p=new PrintWriter(Writer w)
Methods:
1.void write(int ch)------> to write character
2.void write(String s)-----> to write String
3.void write(char[] ch)-----to write character
4.void print(int i) -----directory add the int
5.void print(String s)
6.void print(char[] ch)
7.void print(boolean b)
8.void print(char ch)
9.void print(long l)
10.void println(int i) -----directory add the int
11.void println(String s)
12.void println(char[] ch)
13.void println(boolean b)
14.void println(char ch)
15.void println(long l)
PrintWriter Example:
Import java.io.*;
Class Sample
{
public static void main(String add[])throws IOException
{
PrintWriter pw=new PrintWriter(“laxman.txt”);
Pw.write(100);
Pw.print(100);
Pw.print(true);
Pw.print(“laxman”);
Pw.print(“scjp”);
Pw.print(“Hyderabad”);
Pw.flush();
Pw.close();
}
}
Serialization
Java Serialization(serializable):
The process of saveing an object data to a file is called
serialization.
writeObject(o)
The process of retrieving an object data from the file is called
deserialization.
By using read object method of ObjectInputStream we can achieve
deserialization.
ObjectInputStream ----->FileInputStream------>abc.txt
serialization Example:
class Dog implements Serializable
{
int i=10;
int j=20;
transient int k=30;
}
public class Myser1 {
public static void main(String arg[])throws Exception
{
Dog d1=new Dog();
FileOutputStream fos=new FileOutputStream("abc.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(d1);
FileInputStream fis=new FileInputStream("laxman.txt");

ObjectInputStream ois=new ObjectInputStream(fis);
Dog d2=(Dog)ois.readObject();
System.out.println(d2.i+"......"+d2.j);
}
}
It is suggestable our java bean classes should implements

serialization.
Ois.readObject() method returns an object in the
java.lang.Object form .we should perform the type casting.
All the Objects doesn’t have the capability of saving to the file .Only
serializable Objects having this capability.
An object is said to be serializable if and only if the corresponding class
implements serializable interface(directly or indirectly).
The serializable interface doesn’t contain any method and it is an
example of marker interface.
If an object is non-serializable then we are not allow to save this object
to the file.vilation leads to RTE saying java.io.net.serializableException.
All the wrapper classes,collection classes and arrays of primitives
already implemented serializable interface.Hence these are serializable
objects.
If you don’t want to save ,the value of a particular instance variable
while performing serialization ,then we have to declare those variable
as transient.
If we are declearing a variable as the transient ,while saving an object
to the file JVM ignores ,the value of this variable ,instead of saving
original value ,JVM stores default value for the transient
variables.Hence transient means ‘not to serializable”.
Static variables are not part of object state hence they never
participated in the serialization process.A single copy of the static
variable will exist and all the objects will share that copy.
Final variable also never participated in the serialization.there is no
effect of declearing a final or a static variable as transient.
Object Graphs:
When ever we are saving an objects to the file all the objects
which are reachable from that object by default saving to the
file.This group of object is called ObjectGraph.
Example:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Dog1 implements Serializable

{
Cat c=new Cat();
}
class Cat implements Serializable
{
int i=10;
Rat r=new Rat();
}
class Rat implements Serializable
{
int j=20;
}
class SerDemo2
{
{
Dog1 d=new Dog1();
FileOutputStream fos=new FileOutputStream("abc1.txt");
oos.writeObject(d);
FileInputStream fis=new FileInputStream("abc1.txt");
Dog1 d1=(Dog1)ois.readObject();
System.out.println(d1.c.i);
System.out.println(d1. c.r.j);
}
}
When ever we are saving an object to the file.All the object present in
its objects graph by default will save to the file .Hence all the objects
present in the object graph also must be serializable .voilation leads to
RTE saying NotSerializable Exception”.
Example:
class Dog implements serializable
{
Cat c=new Cat();
}
Class Cat
{
Int j=20;
}
Class SerialDemo
{
{
Dog d=new Dog();
FileOutputStream fos=new FileOutputStream(“abc.txt”);
Oos.writeObject(d);
FileInputStream fis=new FileInputStream(“abc.txt’);
Dog d1=(Dog)ois.readObject();
System.out.println(d1.c.j);
System.out.println(d1. c.j);
}
}
Customized Serialization:
During default serialization there may be a chance of loss of
information .To over come these problems ,we can perform customized
serialization .
We can perform customized serialization by using the following two call
back methods.
1.private void writeObject(OutputStream os)
JVM calls this writeObject method at the time of serialization.
2.private void readObject(inputStream is)
the JVM calls this method at the time of deserialization
automatically.
The above two methods are called by JVM automatically at the time of
serialization and deserialization .Hence these methods are considered
as call back methods.
Customized Serialization Example:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Dog2 implements Serializable

{
transient Cat1 c=new Cat1();
private void writeObject(ObjectOutputStream os)throws Exception
{
os.defaultWriteObject();
int i=c.j;
os.writeInt(i);
}
private void readObject(ObjectInputStream is)throws Exception
{
is.defaultReadObject();
int i=is.readInt();
c=new Cat1();
c.j=i;
}
}
class Cat1
{
int j=20;
}
public class SerDemo3
{
{
Dog2 d=new Dog2();
FileOutputStream fos=new FileOutputStream("abc.txt");
oos.writeObject(d);
FileInputStream fis=new FileInputStream("abc.txt");
Dog2 d1=(Dog2)ois.readObject();
System.out.println(d1.c.j);
}
}
Date Format
Before going learn about Date Format We have to know the Locale
class.
DateFormat:
The representation of date is varied from location to location ,we can
format the date for a specific locale by using date format class.It is
available in java.text.package.It is an abstract class we are not allowed
to create an instance of date format by using constructor.
DateFormat d=new DateFormat() -------->not valid
Getting DateFormat object for the default locale:
public static DateFormat getInstance();
public static DateFormat getDateInstance();
public static DateFormat getDateinstance(int style);
the allowed styles are :
DateFormat.FULL(0);
DateFormat.LONG(1);
DateFormat.MEDIUM(2);
DateFormat.SHORT(3);
Getting DateFormat Object for the specific locale:
public static DateFormat getDateInstance(int style,Locale l)
Formating and parsing date:
Public String format(Date d) ----->from java date format to locale
specific date format
Public Date parse(String s) throws parseException //from locale specific
format to date format.
Example Date Format:

Import java.text.*;
Import java.util.*;
Class DateFormatDemo
{
{
DateFormat d=DateFormat.getDateInstance(0);
System.out.println(“Full form is:”+d.format(new date());
System.out.println(“lond form;”+
(DateForamt.getDateInstance(1)).format(new Date());
System.otu.println(“medium is:”); //Feb 3, 2008
System.out.println(“short is”); // 2/3/08
System.otu.println(“Full is:”); //Sunday,febravary3, 2008
System.out.println(“Long is”); // Febravary 3 ,2008
}
Demo:
For India,italy
DateFormat in=DateFormat.getDateInstance(0,new Locale(‘pa”,”In”);
DateFormat us=DateFormat.getDateInstance(0);
DateForamt it=DateFormat.getDateInstance(0,new Locale.ITALY);
System.out.println(“India style:”+in.format(new Date()); //
Sunday,febravary 3,2008
System.out.println(“us style:”+us.format(new Date()); // Sunday
Febravary 3, 2008
System.out.println(“Italy style:”+it.format(new Date()); // dominica
3,febravary 2008.
Getting DateFormat object for representing both date and time.
Public static DateFormat getDateTimeInstance();
Public static DateFormat getDateTimeInstance(int date style, int time
style);
Public static DateForamt getDateTimeInstance(int date style, int time
style, locale l);
Demo:
DateFormat in=DateFormat.getDateTimeInstance(0,0,Locale.UK);
System.out.println(in); // 03 , febravary 2008 12:10:50 0’clock IST
Us: Sunday febravary 3,2008 12:10:50 pm IST
Number Format class
Before Going to learn about Number Format Batter know about Locale
Class
Number Format:
By using number format object we can represent the number specific
to a particular region (a particular locale).This class present in java
.text package.It is an abstract class we are not allowed to create object
by using constractor.
i.e NumberFormat nf=new NumberFormat() -----> not valid
Getting NumberFormat object for defaultLocale using factory method:

static NumberFormat getInstance();
static NumberFormat getNumberInstance();
static NumberFormat getCurrrencyInstance();
static NumberFormat getPercentInstance();
return NumberFormat object for representing currency and
percentage.
Getting NumberFormat object for a particular Locale:

static NumberFormat getInstance(Locale l);
static NumberFormat getNumberInstance(Locale l);
static NumberFormat getCurrencyInstance(Locale l);
static NumberFormat getPercentInstance(Locale l);
Methods of the NumberFormat class:

String format (long l);
String format(double d);
Number parse(String s)throws parseException ---->This method is for
converting locale specific to java number form.It throws a checked
exception parseException.
Example to Display the currency value 1234.343 for locations India

.Italy and us:
Import java.text.NumberFormat;
Import java.util.*;
Class NFDemo
{
Public staic void main(String arg[])
{
double d=123456.789;
Locale India=new Locale(“pa”,”IN”);
NumberFormat nf=NumberFormat.getCurrencyInstance(India);
String s=nf.format(d);
Systm.out.println(“india notation is:”+s);
NumberFormat nf=NumberFormat.getCurrencyInstance(locale.ITALY);
NumberFormat
nf=NumberFormat.getCurrencyInstance(locale.UNITEDSTATES);
}}}
output:
INR123,456.789
C1 123.456.789
$123,456.789
we can set the maximam and minimum number of digits for integer
and fractional parts.For this we can use the following methods of
NumberFormat class.
public void setMaximumFractionalDigits(int n);
public void setMinimumFractionalDigits(int n);
public void setMaximumIntegerDigits(int n);
public void setMinimumIntegerDigits(int n);
Example:
Import java.text.*;
Import java.util.*;
Class NFDemo
{
public static vopid main(String arg[])
{
double d=123.456;
NumberFormat nf=NumberFormat.getInstance();
Systm.out.println(nf.format(d)); //123.456
nf. setMaximumFractionalDigits(2);
System.out.println(nf.format(d)); //123.46
nf.setMinimumFractionalDigits(5);
nf.setMaximumIntegerDigits(2);
The most significant bits will be lost
nf.setMinimumIntegerDigits(6);
}
}
Constructors
The purpose of Constructor is to perform of our creted object.
Whenever we are calling new operator for the creation of object, it
calls constructor automatically to provide initialization for the object.
class Student
{
String name; int rno;
Student(String name, int rno) ----> Constructor
{
this.name=name;
this.rno=rno;
}
{
Student s=new Student(“xxx”,101);
Student s1=new Student(“yyy”,102);
-------
------
}
}
Rules Of Constructor :
1. Constructor concept is applicable for every class including abstract
class also.
2. Interface doesn’t have Constructor’s concept.
3. The name of the const4ructor and the name of the class must be
same.
4. The allowed modifiers for the constructors are public, private,
protected, and default. If you are applying any other we will get a CTE
saying “modifier xxx not allowed her”.
5. We can’t give return type for the constructor even void also.
If we will give return type for the constructor that thing as a method
instead of constructor that thing as a method instead of constructor
(so,there is no CTE). Ie., it is legal (but stupid) to have a method whose
name same as classname.
Default Constructor:-
If the programmer is not writing any constructor, then only compiler
will generate a default constructor.
Ie., either programmer written constructor or compiler generated must
present in your class but not both at a time.
Prototype of default constructor shown below:
a).Programmer written code:- class Test{}
class Test
{
Test()
{
super();
}
}
The default constructor is always no argument constructor.
The access modifier of the default constructor is sane as access
modifier of the class (public & default only).
The default constructor contains only one statement which is ‘no arg
call to super class Constructor ‘ (super();)
b) Programmer written code:-
class Test {
Test(int i)
{
}}
class Test {
Test(int i)
{
super();
}}
c). Programmer written code:-

class Test {
Test(int i)
{
super();
System.out.println(“Hai”);
}}
Compiler generated code:- no new code is going to generate.
d). Programmer written code:-

class Test {
void Test()
{
}
}
class Test {
void Test()
{
}
Test()
{
super();
}}
e). Programmer written code:-
class Test {
Test()
{
this(10);
}
Test(int i)
{
}}
class Test {
Test() {
this(10);
}
Test(int i) {
super();
}}
The first line inside a constructor must be a call to super class
constructor ( by using super();) or a call to overload
constructor of the same class. (by using ‘this’ keyword).
If you are not writing the first line as either ‘super()’ or ‘this’
then compiler will always keep a no arg call to super class
constructor (super();).
1. Allowed only in Constructors.
2. Must be first statements.
3.Either super() or this, but not both.
We can invoke another constructor from constructor from a method
violation leads to CTE. i.e, super() or this must be used inside the
constructor only not anywhere else.
Overloaded Constructors:
We are allowed to keep more than one constructor inside a class ,
which are considered as overloaded constructors. We can’t override
the constructors, because they belong to the same Ex: class Test {
Test(int i){}
Test(){} ---->Overloaded Constructors
}
Constructors are not inherited and hence we are not allowed to
override a constructor.
while recursive method invocation we will get stackoverflowException
But in case of constructors we will get compile time error.
If we are writing any constructor in our class it is recommended to
place default constructor also. Otherwise we should take care while
writing the constructor child case.
If the parent class constructor throws some Checked Exception, while
writing child class constructors we should take care.In case of
unchecked exception no rule.
Recursive Constructor invocation:
class Sample {
Sample() // This is a compile time problem
{
this(10);
}
Sample(int i)
{
this(); // Invalid, CTE: recursive constructor invocation
}
{
}
}
Constructing the Child class constructors:
Example:
class P {
P()
{ super(); }
}
class C extends P
{
C() {
super();
} } //valid
Example:
class P {
P(int i)
{
}
}
class C extends P
{
C()
{
super(10); // valid (without super invalid)
}
}
Example: class P
{
P() throws Exception ----> checked exception
{}
}
class C extends P
{
C() // compile time error unhandled exception type exception
{}
}
Java Generics
The problems of legacy collections:
There is no type safety for the collection objects.
Suppose we are constructing array list object to that we can add any
kind of object.
Suppose if our requirement is to add only String objects,by mistake if
we are adding any non string objects,still the compiler compiles the
code without raise any problem.
But at the time of retrieving these objects we may get class cast
exception.
Example:
ArrapList l=new ArrayList();
l.add(new Integer(10));
String n1=(String)l.get(0);
String n2=(String)l.get(1);
Hence these is no type safety for the collection objects.
While retrieving the elements from the collection object we should
explicitly perform type casting even though we know the type of
elements present in the collection.
To resolve the above two problems Sun people provided generics
concept in the 1.5 version.
Hence by using generic we can provide type safely for the
collection objects and we can resolve explicit type casting
problems.
i.e no need to type cast at the time of retrieving elements from the
collection.
ArrayList <String > l= new ArrayList <String >();

This ArrayList can accept only string objects.This is declaring a generic
collection object .
By mistake of we are adding any non string object .it will results in the
compail time problem.Hence by using generics we can provide the
type safety for the collection objects.
At the time of retrieving we can directly assign to the String type no
need to problem explicit typecasting.
ArrayList <String> l=new ArrayList<String>();
l.add(“scjp”);
l.add(10); // compile time error (CTE)
String n1=l.get(0);
i.e no need to perform explicit type casting so,generics are nothing but
parametrized collections because by using this we can define the type
parameter.
program to define ArrayList of String objects and display the contents

of ArrayList by using some method:
import java.util.*;
class GenericDemo
{
{
ArrayList<String> l=NEW ArrayList <String >();
l.add(“a”);
l.add(“b”);
l.add(“c”);
show(l);
}
public static void show(ArrayList<String> l)
{
}
}
To add any kind of objects to the ArrayList we can declare generic

arraylist as follows
ArrayList<Object> l=new ArrayList<Object>(); is equal to

List<Object> l=new ArrayList<Object>(); (valid)
List<Object> l=new ArrayList<String>(); (not valid)
Because polymorphism can be applicable for the base type not for the
parameter type.
ArrayList<Integer> l=new ArrayList<Integer>(); (valid)

Object<Integer> l=new ArrayList<Integer>(); (valid)
Object<number> l=new ArrayList<integer>(); (not valid)
ArrayList<int> l=new ArrayList<int>(); (not valid)
Since parameter must not be primitive type .
We can’t define primitive type as the parameter of collection
classes.violation leads to compail time error.
Saying unexpected type found:int required:reference
java net package
INTRODUCTION TO NETWORKING:
The Java execution environment is designed so that applications can
be easily written to efficiently communicate and share processing with
remote systems. Much of this functionality is provided with the
standard Java API within the java.net package.
TCP/IP Protocols:
Three protocols are most commonly used within the TCP/IP scheme
and a closer investigation of their properties is warranted.
Understanding how these three protocols (IP, TCP, and UDP) interact is
critical to developing network applications.
Internet Protocol (IP):
IP is the keystone of the TCP/IP suite. All data on the Internet flows
through IP packets, the basic unit of IP transmissions. IP is termed a
connectionless, unreliable protocol. As a connectionless protocol, IP
does not exchange control information before transmitting data to a
remote system—packets are merely sent to the destination with the
expectation that they will be treated properly. IP is unreliable because
it does not retransmit lost packets or detect corrupted data. These
tasks must be implemented by higher level protocols, such as TCP.
IP defines a universal-addressing scheme called IP addresses. An IP

address is a 32-bit number and each standard address is unique on the
Internet. Given an IP packet, the information can be routed to the
destination based upon the IP address defined in the packet header. IP
addresses are generally written as four numbers, between 0 and 255,
separated by period. (for example, 124.148.157.6)
While a 32-bit number is an appropriate way to address systems for

computers, humans understandably have difficulty remembering them.
Thus, a system called the Domain Name System (DNS) was developed
to map IP addresses to more intuitive identifiers and vice-versa. You
can use www.netspace.org instead of 128.148.157.6.
It is important to realize that these domain names are not used nor
understood by IP. When an application wants to transmit data to
another machine on the Internet, it must first translate the domain
name to an IP address using the DNS. A receiving application can
perform a reverse translation, using the DNS to return a domain name
given an IP address. There is not a one-to-one correspondence
between IP addresses and domain names: A domain name can map to
multiple IP addresses, and multiple IP addresses can map to the same
domain name.
Java provides a class to work with IP Addresses, InetAddress.
THE INETADDRESS CLASS:

This class represents an Internet Protocol (IP) address.
Applications should use the methods getLocalHost, getByName, or
getAllByName to create a new InetAddress instance. Transmission
Control Protocol (TCP)
Most Internet applications use TCP to implement the transport layer.

TCP provides a reliable, connection-oriented, continuous-stream
protocol. The implications of these characteristics are:
Reliable. When TCP segments, the smallest unit of TCP transmissions,
are lost or corrupted, the TCP implementation will detect this and
retransmit necessary segments.
Connection-oriented. TCP sets up a connection with a remote system
by transmitting control information, often known as a handshake,
before beginning a communication. At the end of the connect, a similar
closing handshake ends the transmission.
Continuous-stream. TCP provides a communications medium that
allows for an arbitrary number of bytes to be sent and received
smoothly; once a connection has been established, TCP segments
provide the application layer the appearance of a continuous flow of
data.
Because of these characteristics, it is easy to see why TCP would be

used by most Internet applications. TCP makes it very easy to create a
network application, freeing you from worrying how the data is broken
up or about coding error correction routines. However, TCP requires a
significant amount of overhead and perhaps you might wish to code
routines that more efficiently provide reliable transmissions given the
parameters of your application. Furthermore, retransmission of lost
data may be inappropriate for your application, because such
information's usefulness may have expired.
An important addressing scheme which TCP defines is the port. Ports

separate various TCP communications streams which are running
concurrently on the same system. For server applications, which wait
for TCP clients to initiate contact, a specific port can be established
from where communications will originate. These concepts come
together in a programming abstraction known as sockets.
User Datagram Protocol (UDP) :
UDP is a low-overhead alternative to TCP for host-to-host

communications. In contrast to TCP, UDP has the following features:
Unreliable. UDP has no mechanism for detecting errors nor
retransmitting lost or corrupted information.
Connectionless. UDP does not negotiate a connection before
transmitting data. Information is sent with the assumption that the
recipient will be listening.
Message-oriented. UDP allows applications to send self-contained
messages within UDP datagrams, the unit of UDP transmission. The
application must package all information within individual datagrams.
For some applications, UDP is more appropriate than TCP. For instance,
with the Network Time Protocol (NTP), lost data indicating the current
time would be invalid by the time it was retransmitted. In a LAN
environment, Network File System (NFS) can more efficiently provide
reliability at the application layer and thus uses UDP.
As with TCP, UDP provides the addressing scheme of ports, allowing for
many applications to simultaneously send and receive datagrams. UDP
ports are distinct from TCP ports. For example, one application can
respond to UDP port 512 while another unrelated service handles TCP
port 512.
Uniform Resource Locator (URL):

While IP addresses uniquely identify systems on the Internet, and ports
identify TCP or UDP services on a system, URLs provide a universal
identification scheme at the application level. Anyone who has used a
Web browser is familiar with seeing URLs, though their complete
syntax may not be self-evident. URLs were developed to create a
common format of identifying resources on the Web, but they were
designed to be general enough so as to encompass applications that
predated the Web by decades. Similarly, the URL syntax is flexible
enough so as to accommodate future protocols.
URL Syntax :
The primary classification of URLs is the scheme, which usually
corresponds to an application protocol. Schemes include http, ftp,
telnet, and gopher. The rest of the URL syntax is in a format that
depends upon the scheme. These two portions of information are
separated by a colon to give us:
scheme-name:scheme-info
Thus, while mailto:dwb@netspace.org indicates "send mail to user dwb

at the machine netspace.org," ftp://dwb@netspace.org/ means "open
an FTP connection to netspace.org and log in as user dwb."
General URL Format:

Most URLs used conform to a general format that follows the following
pattern:
scheme-name://host:port/file-info#internal-reference
Scheme-name is a URL scheme such as HTTP, FTP, or Gopher. Host is

the domain name or IP address of the remote system. Port is the port
number on which the service is listening; since most application
protocols define a standard port, unless a non-standard port is being
used, the port and the colon which delimits it from the host is omitted.
File-info is the resource requested on the remote system, which often
times is a file. However, the file portion may actually execute a server
program and it usually includes a path to a specific file on the system.
The internal-reference is usually the identifier of a named anchor
within an HTML page. A named anchor allows a link to target a
particular location within an HTML page. Usually this is not used, and
this token with the # character that delimits it is omitted.
Java and URLs:

Java provides a very powerful and elegant mechanism for creating
network client applications allowing you to use relatively few
statements to obtain resources from the Internet. The java.net
package contains the sources of this power, the URL and
URLConnection classes.
THE URL CLASS :
Class URL represents a Uniform Resource Locator, a pointer to a

"resource" on the World Wide Web. A resource can be something as
simple as a file or a directory, or it can be a reference to a more
complicated object, such as a query to a database or to a search
engine.
In general, a URL can be broken into several parts. The previous

example of a URL indicates that the protocol to use is http (HyperText
Transport Protocol) and that the information resides on a host machine
named www.ncsa.uiuc.edu. The information on that host machine is
named demoweb/url-primer.html. The exact meaning of this name on
the host machine is both protocol dependent and host dependent. The
information normally resides in a file, but it could be generated on the
fly. This component of the URL is called the file component, even
though the information is not necessarily in a file.
A URL can optionally specify a "port", which is the port number to

which the TCP connection is made on the remote host machine. If the
port is not specified, the default port for the protocol is used instead.
For example, the default port for http is 80. An alternative port could
be specified as:
http://www.ncsa.uiuc.edu:8080/demoweb/url-primer.html
A URL may have appended to it an "anchor", also known as a "ref" or a

"reference". The anchor is indicated by the sharp sign character "#"
followed by more characters. For example,
http://java.sun.com/index.html#chapter1
This anchor is not technically part of the URL. Rather, it indicates that
after the specified resource is retrieved, the application is specifically
interested in that part of the document that has the tag chapter1
attached to it. The meaning of a tag is resource specific.
An application can also specify a "relative URL", which contains only

enough information to reach the resource relative to another URL.
Relative URLs are frequently used within HTML pages.
For example, if the contents of the URL:

http://java.sun.com/index.html
contained within it the relative URL:

FAQ.html
it would be a shorthand for:

http://java.sun.com/FAQ.html
The relative URL need not specify all the components of a URL. If the
protocol, host name, or port number is missing, the value is inherited
from the fully specified URL. The file component must be specified. The
optional anchor is not inherited.
Example for URL :
GetURLApp.java
import java.net.URL;
import java.net.MalformedURLException;
import java.io.*;
public class GetURLApp

{
{
try
{
if(args.length!=1) error("Usage: java GetURLApp URL");
System.out.println("Fetching URL: "+args[0]);
URL url = new URL(args[0]);
BufferedReader inStream = new BufferedReader(
new InputStreamReader(url.openStream()));
String line;
while ((line = inStream.readLine())!= null)
{
System.out.println(line);
}
inStream.close();
}
catch (MalformedURLException ex)
{
error("Bad URL");
}
catch (IOException ex)
{
error("IOException occurred.");
}
}
public static void error(String s){

System.exit(1);
}
}
THE URLCONNECTION CLASS :

The abstract class URLConnection is the superclass of all classes that
represent a communications link between the application and a URL.
Instances of this class can be used both to read from and to write to
the resource referenced by the URL. In general, creating a connection
to a URL is a multistep process:
openConnection()
connect()
Manipulate parameters that affect the connection to the remote

resource.
Interact with the resource; query header fields and contents.
1. The connection object is created by invoking the openConnection

method on a URL.
2. The setup parameters and general request properties are
manipulated.
3. The actual connection to the remote object is made, using the
connect method.
4. The remote object becomes available. The header fields and the
contents of the remote object can be accessed.
The setup parameters are modified using the following methods:
• setAllowUserInteraction
• setDoInput
• setDoOutput
• setIfModifiedSince
• setUseCaches
and the general request properties are modified using the method:
setRequestProperty
Default values for the AllowUserInteraction and UseCaches parameters
can be set using the methods setDefaultAllowUserInteraction and
setDefaultUseCaches. Default values for general request properties
can be set using the setDefaultRequestProperty method.
Each of the above set methods has a corresponding get method to

retrieve the value of the parameter or general request property. The
specific parameters and general request properties that are applicable
are protocol specific.
The following methods are used to access the header fields and the
contents after the connection is made to the remote object:
getContent
getHeaderField
getInputStream
getOutputStream
Certain header fields are accessed frequently. The methods:
getContentEncoding
getContentLength
getContentType
getDate
getExpiration
getLastModified
provide convenient access to these fields. The getContentType method
is used by the getContent method to determine the type of the remote
object; subclasses may find it convenient to override the
getContentType method.
In the common case, all of the pre-connection parameters and general

request properties can be ignored: the pre-connection parameters and
request properties default to sensible values. For most clients of this
interface, there are only two interesting methods: getInputStream and
getObject, which are mirrored in the URL class by convenience
methods.
More information on the request properties and header fields of an http
connection can be found at:
http://www.w3.org/hypertext/WWW/Protocols/HTTP1.0/draft-ietf-http-
spec.html
TCP Socket Basics:
Sockets were originally developed at the University of California at

Berkeley as a tool to easily accomplish network programming.
Originally part of UNIX operating systems, the concept of sockets has
been incorporated into a wide variety of operating environments,
including Java.
What is a Socket?
A socket is a handle to a communications link over the network with
another application. A TCP socket is one that utilizes the TCP protocol,
inheriting the behavior of that transport protocol. Four pieces of
information are needed to create a TCP socket:
• The local system's IP address

• The TCP port number which the local application is using
• The remote system's IP address
• The TCP port number to which the remote application is responding
Sockets are often used in client-server applications: A centralized

service waits for various remote machines to request specific
resources, handling each request as it arrives. In order for clients to
know how to communicate with the server, standard application
protocols are assigned well-known ports. On UNIX operating systems,
ports below 1024 can only be bound by applications with super-user
(for example, root) privileges, and thus for control, these well-known
ports lie within this range, by convention. Some well known ports are
shown in the following table.
Well-known TCP ports and services
Port
Service
21 FTP
23 Telnet
25 SMTP (Internet Mail Transfer)
79 Finger
80 HTTP
For many application protocols, you can merely use the Telnet
application to connect to the service port and then manually emulate a
client. This may help you understand how client-server
communications work.
Client applications must also obtain, or bind, a port to establish a

socket connection. Because the client initiates the communication with
the server, such a port number could conveniently be assigned at
runtime. Client applications are usually run by normal, unprivileged
users on UNIX systems, and thus these ports are allocated from the
range above 1024. This convention has held when migrated to other
operating systems, and client applications are generally given a
dynamically-allocated port above 1024.
Because no two applications can bind the same port on the same
machine simultaneously, a socket uniquely identifies a
communications link. Realize that a server may respond to two clients
on the same port, since the clients will be on different systems and/or
different ports; the uniqueness of the link's characteristics are
preserved.
JAVA TCP SOCKET CLASSES :
Java has a number of classes, which allow you to create socket-based

network applications. The two classes you use include java.net.Socket
and java.net.ServerSocket.
THE SERVERSOCKET CLASS
public class ServerSocket extends Object
This class implements server sockets. A server socket waits for

requests to come in over the network. It performs some operation
based on that request, and then possibly returns a result to the
requester.
The actual work of the server socket is performed by an instance of the

SocketImpl class. An application can change the socket factory that
creates the socket implementation to configure itself to create sockets
appropriate to the local firewall.
Example for ServerSocket:
ServerExample.java
import java.io.*;
import java.net.*;
import java.util.Date;
public class ServerExample

{
{
ServerSocket server = null;
Socket socket = null;
BufferedOutputStream send = null;
try
{
server = new ServerSocket(3000);
System.out.println("server started");
while(true)
{
socket = server.accept();
send = new BufferedOutputStream(socket.getOutputStream());
String date = (new Date()).toString();
byte data[] = new byte[date.length()];
data = date.getBytes();
send.write(data,0,data.length);
send.flush();
System.out.println("data flushed");
send.close();
socket.close();
}
}
catch(Exception err) {
System.out.println("Exception in transferring data to client");
}
}
}
THE SOCKET CLASS :
This class implements client sockets (also called just "sockets"). A

socket is an endpoint for communication between two machines. The
actual work of the socket is performed by an instance of the
SocketImpl class. An application, by changing the socket factory that
creates the socket implementation, can configure itself to create
sockets appropriate to the local firewall.
Example for Socket :
import java.io.*;
import java.net.*;
public class ClientExample {
public static void main(String args[]) {
Socket socket = null;
BufferedInputStream receive = null;
if(args.length == 0){
System.out.println("Usage : java ClientExample
My own ConnectionPool implementation

By seeing this example we can get the two things
1- how to implement our own connection

2- why sun gives wait, notify methods in object class.
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Vector;
public class MyConnectionPool {
Vector connections= null;
static MyConnectionPool instance=null;
public static final int MAX_CONNECTIONS=10;
//removeAllConnections objects
public synchronized void removeAllConnections() {
if (connections==null) {
return;
}
try {
int sz= connections.size();
for (int i=0; i < sz/2; i++) {
Connection c= (Connection) connections.elementAt(i);
c= null;
connections.remove(i);
}
if (connections!= null && connections.size() > 0) {
connections.removeAllElements();
}
connections= null;
}catch (Exception e) {
System.out.println( "Error "+ e);
}
instance =null;
}
//getInstance...
public static MyConnectionPool getInstance() {
if (instance ==null)
instance= new MyConnectionPool();
return instance;
}
//initializing all connections upto max limit i.e upto 10 connections...

public synchronized void initialize() {
if (connections ==null) {
try {
Class.forName(" com.mysql.jdbc.Driver ");
connections= new Vector();
int count =0;
while (count < MAX_CONNECTIONS) {
Connection
connection=DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe","scott","tiger");
connections.addElement(connection);
count++;
}
System.out.println( "total connections created r:" + count);
} catch (Exception e) {
System.out.println( "initialise:Exception ");
instance.removeAllConnections();
initialize();
}
}
}
//getting connection....
public synchronized Connection getConnection() {
System.out.println( "getConnection ");
Connection c =null;
System.out.println("connections"+connections.size());
if (connections== null)
return null;
if (connections.size() > 0) {
System.out.println("i am in if");
c =(Connection) connections.elementAt(0);
connections.removeElementAt(0);
}else
{
System.out.println("i am in else");
try {
wait();
c =(Connection) connections.elementAt(0);
connections.removeElementAt(0);
} catch (InterruptedException e) {
}
}
return c;
}
//put connection obj into vector.
public synchronized void putConnection(Connection c) {
if (c != null) {
connections.addElement(c);
notifyAll();
}}}}
}
Struts Flow
When we deploy our application in the server, at first the container
reads the information from web.xml file.Here ActionServlet object will
be created and init() of ActionServlet will be called.Here ActionServlet
is the backbone to the whole application.
When client send a rewuest using .jsp extension , getters() and reset()
of FormBean will be called. When client fill the form and press on
submit button, then setters() and validate() will be called.
If the data is not valid ,then the form redirects to another page which is
specified in struts-config.xml file. If the data is valid , then only Action
class object will be created.
In Action class , have execute() which have return type of
ActionForward. We can specify the business logic in Model and provide
that object in execute().
After completion of business logic execution , then it forwards to
another page ( either success or failure) , whichis specified in struts-
config.xml file.

Core Java Ex 1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Core Java Ex 1

Uploaded by

Copyright:

Available Formats

Identifier

A name in a java Program is called an Identifier.Which can be

Data type --------------------- Wrapperclass

java byte Datatype :

int data type:

int x=10 ------------> Decimal

int Literal Example:

floating Point Literal:

3.In case of Methods:

4.In case of variables:

Java Beans Naming Conventions:

Array Example:int [] a; (valid)

Example: int [] a=new int [-6]; (not valid)

int [][][] a new int [2][][]; (valid)

Array Element Assignments:

Increment& decrement operators:

Example: int x=4;

Example: int y=++4;

Ex: byte a=10;

final float postive_ infinity ,

* If at least one operand is of string type then + acts as string

SHIFT OPERATORS (1.4 ONLY):-

Right Shift Operator:

Unsigned Right Shift Operator:

Case1: byte b=8 >>1; // valid

Strictfp: Strict floating point

3)Usually static methods are utility methods and we should provide

4) we can overload static methods.but we can not override

Note:- static variables never part of object state hence we are

In procedural programming, an object may contain data or instructions,

How an object is created depends on the language. In a prototype-

To give a real world analogy, a house is constructed according to a

Tightly encapsulated class:

b). class A{ private int y=10;} -----//tightly encapsulated

c). class A{ private int x=20;} ----// A is tightly encapsulated, B is not

d). class A{ int y=20;}

• If the parent class is not tightly encapsulated no child class is

• In java the method signature is compiled with method name and

• In the case of overloading which overloaded method must be

i.e., Automatic Promotion in Overloading:

public void m1(Object o)

public void m1(Animal a)

* While implementing any interface method, we should declare that

5. While overriding the size of the CheckedException should not

public void m1()throws FileNotfoundException //valid

public void m1()throws Exception -->CTE

public void m1()throws RunTimeException //valid

c). Programmer written code:-

d). Programmer written code:-

Abstract public void m1(); // here ; is mandatory.

class Y extends X // error we must provide the implementation for m2

interface variables Declarations:

All the interface variables must perform initialization at the

Tag Interface Marker/Ability Interface:

The primary advantages of a collections framework are that it:

TreeMap Demo program:

public class TreeMapEx1 {

TreeMap Example code with Comparator:

public class TreeMapCom {

Properties:It is the child class of Hashtable For Properties both

Properties Demo Program:

public class HashtableEx1 {

IdentityHashMap Demo Program:

public class IdentityHashMapEx1 {