001 Core 15 - Java Programming - III Sem-converted.docx

of
CHAPTER CONTENT PAGE Nr
I DATA TYPES, CLASS & METHODS 02
II INHERITANCE – SUPER KEYWORD 09
III FINAL KEYBOARD & METHOD 15
IV PACKAGE IN JAVA 18
V JAVA – INTERFACES 26
VI EXCEPTION HANDLING 31
VII FINALLY () & CLOSE () STATEMENT 44
VIII THROW EXCEPTION IN JAVA 50
IX INTRODUCTION OF THREADS IN JAVA 57
X MULTITHREADING 66
XI THREAD METHODS & APPLETS 71

of
CHAPTER – I
DATA TYPES, CLASS & METHODS
Primitive data types in Java
To deal with numerical information, Java uses six predefined data types, called
primitive numerical data types. These are int, long, short, byte, float, and double,
and they allow us to represent integer and real numbers.
Java offers two additional non-numeric primitive data types: char (to
represent alphanumeric characters and special symbols) and Boolean (to
represent the truth values true and false).
We will describe these data types in Java by specifying for each of them:
The domain:
The set of possible values that can be represented in the memory of the
computer by means of the primitive data type (note that this set will always be
finite);
The set of operations: operators of the programming language that allow us
to perform elementary operations on values of the primitive data type (e.g., +, -, /, *,
etc.)
The set of literals: symbols of the language that define values of the primitive
data type (e.g., 10, 3.14, ’A’, true, etc.)
Moreover, we will specify the size of the memory occupied by a value of a
certain data type, which will be significant for the numeric data types.
The data type int
The most commonly used integer type is int. It is a signed 32-bit type that
has a range from –2,147,483,648 to 2,147,483,647. In addition to other uses,
Variables of type int are commonly employed to control loops and to index arrays.
Type Int
Dimension 32 bit (4 byte)
Domain the set of integer numbers in the interval [ 2
− 31,
+231 − 1]
(More than 4 billion values)
Operations+ Sum
- Difference
* Product
/ integer division
rest of the integer division
Literals sequences of digits denoting values of the domain
(e.g.,
275930)
Example:
int a, b, c;// Declaration of variables of type int a = 1;// Use of
literals b = 2;
c = a + b;// Arithmetic expression that involves operators of the language
Writing of numbers of type int: -
To write a number of types int, we can directly use the print() or println()
methods:
Example:
int i = 1; System.out.println(4); System.out.println(i); System.out.println(i + 4);

Example:
Byte a, b, c; // Declaration of variables of byte type
b = Short.parseShort("22605");// Conversion from String to short c = ba;//
Arithmetic expression
Other primitive data types for integer numbers: long
long is a signed 64-bit type and is useful for those occasions where an int type is
not large enough to hold the desired value. The range of a long is quite large. This
makes it useful when big, whole numbers are needed.
Page 3 of
Note: the symbol + can be used both for the sum of two numbers and to
concatenate two strings: "aaa" + "bbb" corresponds to "aaa”. concat("bbb").
Note the difference between the following two statements:
System.out.println(3 + 4); // prints 7 (as int); + denotes sum System.out.println("3" +
4); // prints 34 (as String), since the integer 4 is
// first converted to a String; + denotes concat
IIn the first statement, “+” is applied to two integers, and hence denotes the addition
operator. Hence, the argument 3+4 of println() is of type int.
IIn the second statement, “+” is applied to a string and an integer, and hence denotes
string concatenation. More precisely, the integer 4 is first converted to the string
"4", and then concatenated to the string "3". Hence, the argument "3"+4 of
println() is of type String.
Both statements are correct, since the method println() is overloaded: The Java
library contains both the versions that accepts an integer as parameter, and a
version that accepts a string as parameter.
Other primitive data types for integer numbers: byte
The smallest integer type is byte. This is a signed 8-bit type that has a range from –128 to
127. Variables of type byte are especially useful when you’re working with a stream of
data from a network or file.
Type Byte
Domain the set of integer numbers in the interval [ 27, +27 1]
− −
=
[ 128, +127]
−
Operation
s
+ Sum
- Difference
* Product
/ integer division
Literals sequences of digits denoting values of the domain (e.g.,
47)
a = 1; // Use of literals
b = Byte.parseByte("47"); // Conversion from String to byte c = a - b; // Arithmetic
expression
other primitive data types for integer numbers: short
Short is a signed 16-bit type. It has a range from –32,768 to 32,767. It is probably
the least- used Java type, since it is defined as having its high byte first (called big-
endian format).
Type Short
Dimension16 bit (2 byte)
Domain the set of integer numbers in the interval [ 215, +215 1] =
− −
[ 32768, +32767]
−

of
Operation
s
+ Sum
- Difference
* Product
/ integer division
Literals sequences of digits denoting values of the domain (e.g.,
22700)
Example:
Short a, b, c; //Declaration of variables of type short1
A=11300;
B=short.parseshort(“22605”); // Conversion from string to short c=b%a; // Arithmetic
expression
Other primitive data types for integer numbers: long
Long is a signed 64-bit data types and is useful for those occasions where an int type is not large
enough to hold the desired value. The range of a long is quite large. This makes it useful
when big, whole numbers are needed.
Example:
long a, b, c; // Declaration of variables of type
long a = 9000000000L;// Use of literals
b = Long.parseLong("9000000000l"); // Conversion from String to long c = b / 300000L
Primitive data types for real numbers: double
In Java there are two primitive data types for representing real numbers.
Due to the way in which real numbers are represented internally in memory, these
numbers are also called floating point numbers.
The data type for floating point numbers that is used by default in the Java
mathematical library is double.
Type Long
Domain the set of integer numbers in the interval
[ 263,
−
+263 1]
−
Operation
s
+ Sum
- Difference
* Product
/ integer division
Literals sequences of digits ending with an l (or L)
denoting values of the domain (e.g.,
9000000000L)

representation in scientific notation (e.g., 314E-2f)
sequences of digits with decimal dot ending with an f (or F) denoting value
Literals
Division
/
product
*
difference
-
Sum
+
Operations
∼ 7 decimal digits
Precision
3.4028235 · 10+38
absolute
Maximum
value
1.4012985 · 10 38
−
absolute
Minimum
value
set of 232 positive and
negativereal numbers
Domain
32 bit (4 byte)
Dimension
Float
Type
Page 5 of
Type Float
Dimension 32 bit(4 byte)
Domain
Set of 232
+ve and -ve
real
numbers
Minimum absolute
value
1.4012985.10-38
Maximum absolute
value
3.4028235.10+38
Precision 7 decimal digits
Operations
+ Sum
- Difference
* Product
/ Division
Literals
sequences of digits with decimal dot ending with an f (or F)
denoting values of the domain (e.g., 3.14f)
representation in scientific notation (e.g., 314E-2f)
Primitive data types for real numbers: float
Example:
float pi, a, b; // Declaration of variables of type float pi = 3.14f; // Use of literals
a = 314E-2F // Use of literals
a++;// Use of increment operator (equivalent to: a = a + 1.0d;)
Writing of numbers of type double or float
To write a number of type double or float, we can directly use the print() or
println() methods:
Example: The following code fragment
double d = 98d; System.out.println("d = " + d); float x = 0.0032f;
System.out.println("x = " + x);
prints on the

of
screen d = 9.8E1 x
= 3.2E-3
Static:
The static can
be: Static
Variables Static
Methods
Static Blocks Of Code.
What is Static Variable in Java?
Static variable in Java is variable which belongs to the class and initialized
only once at the start of the execution.
1. It is a variable which belongs to the class and not to object(instance)
2. Static variables are initialized only once, at the start of the execution. These
3. variables will be initialized first, before the initialization of any
instance variables
4. A single copy to be shared by all instances of the class
5. A static variable can be accessed directly by the class name and doesn’t need
any object
Syntax:
<class-name>.<variable-name>
What is Static Method in Java?
Static method in Java is a method which belongs to the class and not to the object.
A static method can access only static data.
1. It is a method which belongs to the class and not to the object (instance)
2. A static method can access only static data. It cannot access non-
static data (instance variables)
3. A static method can call only other static methods and cannot call a
non-static method from it.
4. A static method can be accessed directly by the class name and doesn’t
need any object
5. A static method cannot refer to "this" or "super" keywords in
anyway Syntax:
<class-name>.<method-name>
Example: How to call static variables &
methods
Step 1: Copy the following code into a editor
public class Demo{
public static void main(String args[]){
Student s1 = new Student();
s1.showData();
Student s2 = new
Student(); s2.showData();
//Student.b++;
//s1.showData();
}}
class Student {
int a; //initialized to zero
static int b; //initialized to zero only when class is loaded not for each object
created. Student(){
//Constructor incrementing static variable b
b++;
}
public void showData()
{ System.out.println("Value of a =
"+a); System.out.println("Value of

of
b = "+b);
}
//public static void increment(){
//a++;
//}
}}Step 2: Save & Compile the code. Run the code as, java Demo.
Step 3: Expected output show below
Following diagram shows, how reference variables & objects are created and static
variables are accessed by the different instances.
Step 4: It is possible to access a static variable from outside the class using the
syntax ClassName.Variable_Name. Uncomment line # 7 & 8 . Save, Compile & Run.
Observe the output.
Value of a =
0 Value of b
= 1 Value of
a = 0 Value
of b = 2
Value of a =
0 Value of b
= 3
Step 5: Uncomment line 25,26 & 27. Save, Compile & Run.

A static block helps to initialize the static data members, just like constructors help to initiali
Following program is the example of java static block.
Example: How to access static block public class Demo {
static int a; static int b; static {
a = 10;
b = 20;
}
public static void main(String args[]) {
Page 8 of
System.out.println("Value of a = " +
a); System.out.println("Value of b =
" + b);
}
}
you will get following output of the
program. Value of a = 10
Value of b = 20

of
Super keyword in
java
CHAPTER - II
INHERITANCE - SUPER KEYWORD
Super keyword in java is a reference variable that is used to refer parent
class object. Super is an implicit keyword creates by JVM and supply each and every
java program for performing important role in three places.
1. Super keyword At Variable Level
2. Super keyword At Method Level
3. Super keyword At Constructor Level
When need of super keyword
Whenever the derived class is inherits the base class features, there is a
possibility that base class features are similar to derived class features and JVM
gets an ambiguity. In order to differentiate between base class features and
derived class features must be preceded by super keyword.
Syntax
super. baseclass features.
Super Keyword at Variable Level
Whenever the derived class inherit base class data members there is a
possibility that base class data member is similar to derived class data member
and JVM gets an ambiguity.
In order to differentiate between the data member of base class and
derived class, in the context of derived class the base class data members must be
preceded by super keyword.
Syntax
Super.baseclassdatamember
name
If we are not writing super keyword before the base class data member
name than it will be referred as current class data member name and base class
data member are hidden in the context of derived class. Program without using
super keyword
Example
class Employee
{
float salary=10000;
}
class HR extends Employee
{
float
salary=20000;
void display()
{
System.out.println("Salary: "+salary);//print current class salary
}
}
classSupervarible
{
publicstaticvoid main(String[]args)

of
In the above program in Employee and HR class salary is common properties of
both class the instance of current or derived class is referred by instance by default but here w
Program using super keyword at variable level Example
classEmployee
{
float salary=10000;
}
class HR extendsEmployee
{
float salary=20000;
void display()
{
System.out.println("Salary: "+super.salary);//print base class salary
}
}
classSupervarible
{
{
HR obj=new HR(); obj.display();
}
}
classStudent
{
HR obj=new
HR();
obj.display();
}
}
Output
Salary: 20000.0
Super Keyword at Method Level
The super keyword can also be used to invoke or call parent class method. It
should be use in case of method overriding. In other word super keyword use when
base class method name and derived class method name have same name.
Example of super keyword at method level
Example

classStudent
{
void message()
{
System.out.println("Good Morning Sir");
}
}
Page 11 of
{
void message()
{
System.out.println("Good Morning Sir");
}
}
classFacultyextendsStudent
{
void message()
{
System.out.println("Good Morning Students");
}
void display()
{
message();//will invoke or call current class message() method
super.message();//will invoke or call parent class message() method
}
publicstaticvoid main(Stringargs[])
{
Student s=newStudent();
s.display();
}
}
Output
Good Morning Students
Good Morning Sir
In the above example Student and Faculty both classes have message() method
if we call message() method from Student class, it will call the message() method of
Student class not of Person class because priority of local is high.
In case there is no method in subclass as parent, there is no need to use
super. In the example given below message() method is invoked from Student class
but Student class does not have message() method, so you can directly call
message() method.
Program where super is not required
Example

of
classFacultyextendsStudent
{
void display()
{
message();//will invoke or call parent class message() method
}
{
Student s=newStudent();
s.display();
}
}
Output
Good Morning Sir
Super Keyword at Constructor Level
The super keyword can also be used to invoke or call the parent class
constructor.
Constructor are calling from bottom to top and executing from top to bottom.
To establish the connection between base class constructor and derived
class constructors JVM provides two implicit methods they are:
 Super()
 Super(...)
Super()
Super() It is used for calling super class default constructor from the context of derived
class constructors.
Super keyword used to call base class constructor
Syntax
classEmployee
{
Employee()
{
System.out.println("Employee class Constructor");
}
}
class HR extendsEmployee
{
HR()
{
super();//will invoke or call parent class
constructor System.out.println("HR class
Constructor");
}
}

classSupercons
{
{
HR obj=new HR();
}
}
Page 13 of
Output
Note: super() is added in each class constructor automatically by compiler.
In constructor, default constructor is provided by compiler automatically but it
also adds super()before the first statement of constructor.If you are creating your own
constructor and you do not have either this() or super() as the first statement,
compiler will provide super() as the first statement of the constructor.
Super(...)
Super(...) It is used for calling super class parameterize constructor from the
context of derived class constructor.
Important rules
Whenever we are using either super() or super(...) in the derived class
constructors the superalways must be as a first executable statement in the body
of derived class constructor otherwise we get a compile time error.
Employee class
Constructor HR class
Constructor

Rule 1 and Rule 3
Page 14 of
The following diagram use possibilities of using super() and super(.......)
Whenever the derived class constructor want to call default constructor of base
class, in the context of derived class constructors we write super(). Which is optional to
write because every base class constructor contains single form of default
constructor?
Rule 2 and Rule 4
Whenever the derived class constructor wants to call parameterized constructor
of base class in the context of derived class constructor we must write super(...). which
is mandatory to write because a base class may contain multiple forms of
parameterized constructors.

of
Final Keyword In Java
CHAPTER- III
FINAL KEYBOARD & METHOD
The final keyword in java is used to restrict the user. The java final keyword can
be used in many context. Final can be:
1. variable
2. method
3. class
The final keyword can be applied with the variables, a final variable that have no
value it is called blank final variable or uninitialized final variable. It can be initialized in
the constructor only. The blank final variable can be static also which will be initialized
in the static block only. We will have detailed learning of these. Let's first learn the
basics of final keyword.
1. Java final variable
If you make any variable as final, you cannot change the value of final
variable(It will be constant).
Example of final variable
There is a final variable speedlimit, we are going to change the value of this
variable, but It can't be changed because final variable once assigned a value can
never be changed.
a. class Bike9{
b. final int speedlimit=90;//final variable
c. void run(){
d. speedlimit=400;
e. }
f. public static void main(String args[]){
g. Bike9 obj=new Bike9();
h. obj.run();
i. }
j. }//end of class
Test it Now
Output:Compile Time
Error
2. Java final method
If you make any method as final, you cannot override it.
Example of final method
a. class Bike{
b. final void run(){System.out.println("running");}
c. }
d.
e. class Honda extends Bike{
f. void run(){System.out.println("running safely with
100kmph");} g.
h. public static void main(String args[]){
i. Honda honda= new Honda();
j. honda.run();
k. }
l. }
Output:Compile Time Error

of
3. Java final class
If you make any class as final, you cannot extend it.
Example of final class
a. final class Bike{}
b. class Honda1 extends Bike{
c. void run(){System.out.println("running safely with
100kmph");} d.
e. public static void main(String args[]){
f. Honda1 honda= new Honda1();
g. honda.run();
h. }
i. }
Output:Compile Time Error
Q. Is final method inherited?
Ans: Yes, final method is inherited but you cannot override it. For Example:
a. class Bike{
b. final void run(){System.out.println("running...");}
c. }
d. class Honda2 extends Bike{
e. public static void main(String args[]){
f. new Honda2().run();
g. }
h. }
Output:running...
Q)What is blank or uninitialized final variable?
A final variable that is not initialized at the time of declaration is known as
blank final variable.
If you want to create a variable that is initialized at the time of creating object and
once initialized may not be changed, it is useful. For example PAN CARD number of an
employee.
It can be initialized only in constructor.
Example of blank final variable
a. class Student{
b. int id;
c. String name;
d. final String PAN_CARD_NUMBER;
e. ...
f. }
Que) Can we initialize blank final variable?
Yes, but only in constructor. For example:
a. class Bike10{
b. final int speedlimit;//blank final
variable c.
d. Bike10(){
e. speedlimit=70;
f. System.out.println(speedlimit);

of
g. }
h.
i. public static void main(String args[]){
j. new Bike10();
k. }
l. }
Output: 70
Static blank final variable
A static final variable that is not initialized at the time of declaration is known
as static blank final variable. It can be initialized only in static block.
Example of static blank final variable
a. class A{
b. static final int data;//static blank final variable
c. static{ data=50;}
d. public static void main(String args[]){
e. System.out.println(A.data);
f. }

of
Packages in Java are the way to organize files when a project has many modules. Same
like we organized our files in Computer. For example, we store all movies in one folder and
Advantage of package
Package in Java
CHAPTER – IV
PACKAGE IN JAVA
A package is a collection of similar types of classes, interfaces and sub-packages.
Purpose of package
The purpose of package concept is to provide common classes and interfaces
for any program separately. In other words if we want to develop any class or
interface which is common for most of the java programs than such common classes
and interfaces must be place in a package.
a. Package is used to categorize the classes and interfaces so that they can be easily
maintained
b. Application development time is less, because reuse the code
c. Application memory space is less (main memory)
d. Application execution time is less
e. Application performance is enhance (improve)
f. Redundancy (repetition) of code is minimized
g. Package provides access protection.
h. Package removes naming
collision. i.
Types of package
Package is classified into two types.

of
1. Predefined or built-in package
2. User defined package
 Predefined or built-in package
These are the package which are already designed by the Sun Microsystem and
supply as a part of java API, every predefined package is collection of predefined
classes, interfaces and sub-package.
 User defined package
If any package is designed by the user is known as user defined package. User
defined package are those which are developed by java programmer and supply as
a part of their project to deal with common requirement.
Rules to create user defined package
a. Package statement should be the first statement of any package program.
b. Choose an appropriate class name or interface name and whose modifier
must be public.
c. Any package program can contain only one public class or only one public
interface but it can contain any number of normal classes.
d. Package program should not contain any main class (that means it should not
contain any main()
e. Modifier of constructor of the class which is present in the package must be a
public. (This is not applicable in case of interface because interface have no
constructor.)
f. The modifier of method of class or interface which is present in the
package must be public (This rule is optional in case of interface because
interface methods by default public)
g. Every package program should be save either with public class name
or public Interface name
Compile package programs
For compilation of package program first we save program with public className.java
and it compile using below syntax:

Syntax
javac-d . className.java
javac-d path className.java
Example
Import above class in below program using import packageName.className
Example
importmypack.A; publicclassHello
{
publicstaticvoid main(Stringarg[])
{
A a=new A(); a.show();
System.out.println("show() class A");
}
}
packagemypack; publicclass A
{
publicvoid show()
{
System.out.println("Sum method");
}
}
Page 20 of
Syntax
Explanations: In above syntax "-d" is a specific tool which is tell to java compiler
create a separate folder for the given package in given path. When we give specific
path then it create a new folder at that location and when we use . (dot) then it crate
a folder at current working directory.
Note: Any package program can be compile but can not be execute or run. These
programs can be executed through user defined program which are importing
package program.
Example of package program
Package program which is save with A.java and compile by javac -d . A.java
Explanations: In the above program first we create Package program which is save with
A.java and compiled by "javac -d . A.java". Again we import class "A" in class Hello
using "import mypack.A;" statement.
Java Access Modifiers – Public, Private, Protected & Default

of
Public, private and protected keywords while practising java programs, these are
called
access modifiers. An access modifier restricts the access of a class, constructor, data
member and method in another class. In java we have four access modifiers:
 Default
Private
Protected
Public
1. Default access modifier
When we do not mention any access modifier, it is called default access
modifier. The scope of this modifier is limited to the package only. This means that if
we have a class with the default access modifier in a package, only those classes that
are in this package can access this class. No other class outside this package can access
this class. Similarly, if we have a default method or data member in a class, it would not
be visible in the class of another package. Lets see an example to understand this:
Default Access Modifier Example in Java
To understand this example, you must have the knowledge of packages in java.
In this example we have two classes, Test class is trying to access the default
method of Addition class, since class Test belongs to a different package, this
program would throw compilation error, because the scope of default modifier is
limited to the same package in which it is declared.
Addition.java
packageabcpackage;
publicclassAddition{
/* Since we didn't mention any access modifier here, it would
* be considered as default.
*/
intaddTwoNumbers(int a,int b){
returna+b;
}
}
Test.java
packagexyzpackage;
/* We are importing the abcpackage
* but still we will get error because the
* class we are trying to use has default access
* modifier.
*/
importabcpackage.*
; publicclassTest{
publicstaticvoid main(Stringargs[]){
Additionobj=newAddition();
/* It will throw error because we are trying to access
* the default method in another package
*/
obj.addTwoNumbers(10,21);
}

of
}
Output:
Exceptionin thread "main"java.lang.Error:Unresolved compilation
problem: The method addTwoNumbers(int,int)from the type Addition
is not visible at xyzpackage.Test.main(Test.java:12)
2. Private access modifier
The scope of private modifier is limited to the class only.
a. Private Data members and methods are only accessible within the class
b. Class and Interface cannot be declared as private
c. If a class has private constructor then you cannot create the object of that
class from outside of the class.
Let’s see an example to understand this:
Private access modifier example in java
This example throws compilation error because we are trying to access the
private data member and method of class ABC in the class Example. The private data
member and method are only accessible within the class.
class ABC{
privatedoublenum=100
; privateint square(int
a){
return a*a;
}
}
publicclassExample{
ABC obj=new ABC();
System.out.println(obj.num);
System.out.println(obj.square(10));
}
}
Output:
Compile- time error
3. Protected Access Modifier
Protected data member and method are only accessible by the classes of
the same package and the subclasses present in any package. You can also say that
the protected access modifier is similar to default access modifier with one
exception that it has visibility in sub classes.
Classes cannot be declared protected. This access modifier is generally used in a
parent child relationship.
Protected access modifier example in Java
Indent In this example the class Test which is present in another package is able
to call the addTwoNumbers() method, which is declared protected. This is because
the Test class extends class Addition and the protected modifier allows the access of
protected members in subclasses (in any packages).
Addition.java
Package abcpackage;

of
public class Addition{
protected int addTwoNumbers(int a,int b){
return a+b;
}
}
Test.java
Package
xyzpackage; Import
abcpackage.*;
class Test extends Addition{
Test obj=new Test();
System.out.println(obj.addTwoNumbers(11,22));
}
}
Output:
33
4. Public access modifier
The members, methods and classes that are declared public can be
accessed from anywhere. This modifier doesn’t put any restriction on the access.
Public access modifier example in java
The method addTwoNumbers() has public modifier and class Test is able to
access this method without even extending the Addition class. This is because public
modifier has visibility everywhere.
Addition.java
Package
abcpackage; public
class Addition{
public int addTwoNumbers(int a,int
b){ returna+b;
}
}
Test.java
Package
xyzpackage; Import
abcpackage.*; Class
Test{
Public static void main(String args[]){
Addition obj=new Addition();
System.out.println(obj.addTwoNumbers(100,1));
}
}
Output:
101
Lets see the scope of these access modifiers in tabular form:
The scope of access modifiers in tabular form
+ + + + +
|Class|Package|Subclass|Subclass|Outside|
|||(same package)|(diff package)|Class|

of
————————————+———————+—————————+——————————----+—
————————----—+————————
public|Yes|Yes|Yes|Yes|Yes|
————————————+———————+—————————+—————————----—+—
————————----—+————————
protected|Yes|Yes|Yes|Yes|No|
————————————+———————+—————————+————————----——+—
———————----——+————————
default|Yes|Yes|Yes|No|No|
————————————+———————+—————————+————————----——+—
———————----——+————————
private|Yes|No|No|No|No|
+ + + + +

/* File name :
NameOfInterface.java */
importjava.lang.*;
// Any number of import statements
Public interface NameOfInterface{
// Any number of final, static fields
// Any number of abstract method declarations
}
Page 26 of
Java - Interfaces
CHAPTER – V
JAVA – INTERFACES
An interface is a reference type in Java. It is similar to class. It is a collection
of abstract methods. A class implements an interface, thereby inheriting the
abstract methods of the interface.
Along with abstract methods, an interface may also contain constants, default
methods, static methods, and nested types. Method bodies exist only for default
methods and static methods.
Writing an interface is similar to writing a class. But a class describes the
attributes and behaviors of an object. And an interface contains behaviors that a
class implements.
Unless the class that implements the interface is abstract, all the methods of
the interface need to be defined in the class.
An interface is similar to a class in the following ways −
a. An interface can contain any number of methods.
b. An interface is written in a file with a .java extension, with the name of the
interface matching the name of the file.
c. The byte code of an interface appears in a .class file.
d. Interfaces appear in packages, and their corresponding bytecode file must
be in a directory structure that matches the package name.
However, an interface is different from a class in several ways, including −
a. You cannot instantiate an interface.
b. An interface does not contain any constructors.
c. All of the methods in an interface are abstract.
d. An interface cannot contain instance fields. The only fields that can appear
in an interface must be declared both static and final.
e. An interface is not extended by a class; it is implemented by a class.
f. An interface can extend multiple interfaces.
Declaring Interfaces
The interface keyword is used to declare an interface. Here is a simple
example to declare an interface –
Example
Following is an example of an interface −
Interfaces have the following properties −
a. An interface is implicitly abstract. You do not need to use the abstract
keyword while declaring an interface.
b. Each method in an interface is also implicitly abstract, so the abstract
keyword is not needed.
c. Methods in an interface are implicitly public.
Example

of
Implementing Interfaces
When a class implements an interface, you can think of the class as signing a
contract, agreeing to perform the specific behaviors of the interface. If a class does not
perform all the behaviors of the interface, the class must declare itself as abstract.
A class uses the implements keyword to implement an interface. The
implements keyword appears in the class declaration following the extends portion of
the declaration.
Example
This will produce the following result –
Output
Mammal eats
Mammal travels
When overriding methods defined in interfaces, there are several rules to be followed:
a. Checked exceptions should not be declared on implementation methods other
than the ones declared by the interface method or subclasses of those declared
by the interface method.
b. The signature of the interface method and the same return type or subtype
should be maintained when overriding the methods.
c. An implementation class itself can be abstract and if so, interface methods need
not be implemented.
When implementation interfaces, there are several rules:
a. A class can implement more than one interface at a time.
b. A class can extend only one class, but implement many interfaces.
/* File name :
Animal.java */
interfaceAnimal{
publicvoid eat();
publicvoid travel();
}
/* File name : MammalInt.java */
Public class Mammal Intimplements Animal{
Public void eat(){
System.out.println("Mammal eats");
}
Public void travel(){
System.out.println("Mammal
travels");
}
publicintnoOfLegs(){
return0;
}
publicstaticvoid
main(Stringargs[]){ MammalInt
m =newMammalInt(); m.eat();
m.travel();
}
}

Package java.util;
Page 28 of
c. An interface can extend another interface, in a similar way as a class can extend
another
class.
Extending Interfaces
An interface can extend another interface in the same way that a class can
extend another class. The extends keyword is used to extend an interface, and the
child interface inherits the methods of the parent interface.
The following Sports interface is extended by Hockey and Football interfaces.
Example
The Hockey interface has four methods, but it inherits two from Sports;
thus, a class that implements Hockey needs to implement all six methods. Similarly, a
class that implements Football needs to define the three methods from Football and
the two methods from Sports.
Extending Multiple Interfaces
A Java class can only extend one parent class. Multiple inheritance is not
allowed. Interfaces are not classes, however, and an interface can extend more
than one parent interface.
The extends keyword is used once, and the parent interfaces are declared in a
comma- separated list.
For example, if the Hockey interface extended both Sports and Event, it
would be declared as –
Example
Tagging Interfaces
The most common use of extending interfaces occurs when the parent interface
does not contain any methods. For example, the MouseListener interface in the
java.awt.event package extended java.util.EventListener, which is defined as –
Example
// Filename: Sports.java
Public interface Sports{
Public void setHomeTeam(String
name); Public void
setVisitingTeam(String name);
}
// Filename: Football.java
Public interface Football extends
Sports{ Public void
homeTeamScored(int points); Public
void visitingTeamScored(int points);
Public void endOfQuarter(int
quarter);
}
// Filename: Hockey.java
Public interface
HockeyextendsSports{ Public void
homeGoalScored();
Public void visitingGoalScored();
Public void endOfPeriod(int period);
Public void overtimePeriod(intot);
Public interface Hockey extends Sports , Event

MyAbstractClassmyClassInstanc
e = new MyAbstractClass();
//not valid
Page 29 of
An interface with no methods in it is referred to as a tagging interface. There
are two basic design purposes of tagging interfaces −
Creates a common parent: As with the EventListener interface, which is extended by
dozens of other interfaces in the Java API, you can use a tagging interface to create
a common parent among a group of interfaces. For example, when an interface
extends EventListener, the JVM knows that this particular interface is going to be
used in an event delegation scenario.
Adds a data type to a class: This situation is where the term, tagging comes from. A
class that implements a tagging interface does not need to define any methods (since
the interface does not have any), but the class becomes an interface type through
polymorphism.
Abstract
A Java abstract class is a class which cannot be instantiated, meaning you cannot
create new instances of an abstract class. The purpose of an abstract class is to
function as a base for subclasses. This Java abstract class tutorial explains how abstract
classes are created in Java; what rules apply to them. This tutorial gets into the purpose
of abstract classes in Java in more detail towards the end of this text.
Declaring an Abstract Class in Java
In Java you declare that a class is abstract by adding the abstract keyword to
the class declaration. Here is a Java abstract class example:
That is all there is to declaring an abstract class in Java. Now you cannot create
instances
ofMyAbstractClass. Thus, the following Java code is no longer valid:
If you try to compile the code above the Java compiler will generate an error,
saying that you cannot instantiate MyAbstractClass because it is an abstract class.
Abstract Methods
An abstract class can have abstract methods. You declare a method abstract by
adding the abstractkeyword in front of the method declaration. Here is a Java
abstract method example:
An abstract method has no implementation. It just has a method signature. Just like
methods in a Java interface.
public interface EventListener
{}
public abstract class MyAbstractClass {
}
public abstract class MyAbstractClass {
public abstract void abstractMethod();
}

public class MySubClass extends MyAbstractClass {
public void abstractMethod() {
System.out.println("My method implementation");
}
}
Page 30 of
If a class has an abstract method, the whole class must be declared abstract. Not all
methods in an abstract class have to be abstract methods. An abstract class can have a
mixture of abstract and non-abstract methods.
Subclasses of an abstract class must implement (override) all abstract methods
of its abstract superclass. The non-abstract methods of the superclass are just
inherited as they are. They can also be overridden, if needed.
Here is an example subclass of the abstract class MyAbstractClass:
Notice how MySubClass has to implement the abstract method abstractMethod()
from its abstract superclass MyAbstractClass.
The only time a subclass of an abstract class is not forced to implement all
abstract methods of its superclass, is if the subclass is also an abstract class.
Exception handling in java with examples
Exception handling is one of the most important feature of java
programming that allows us to handle the runtime errors caused by exceptions. In
this guide, we will learn what is an exception, types of it, exception classes and how to
handle exceptions in java with examples

of
What is an exception?
CHAPTER – VI
EXCEPTION HANDLING
An Exception is an unwanted event that interrupts the normal flow of the
program. When an exception occurs program execution gets terminated. In such
cases we get a system generated error message. The good thing about exceptions is
that they can be handled in Java. By handling the exceptions we can provide a
meaningful message to the user about the issue rather than a system generated
message, which may not be understandable to a user.
Why an exception occurs?
There can be several reasons that can cause a program to throw exception.
For example: Opening a non-existing file in your program, Network connection
problem, bad input data provided by user etc.
Exception Handling
If an exception occurs, which has not been handled by programmer then
program execution gets terminated and a system generated error message is
shown to the user. For example, look at the system generated exception below:
An exception generated by the system is given below
Exceptionin thread "main"java.lang.ArithmeticException:/by zero at
ExceptionDemo.main(ExceptionDemo.java:5)
ExceptionDemo:Theclass name
main :The method name
ExceptionDemo.java :The filename
java:5:Line number
This message is not user friendly so a user will not be able to understand
what went wrong. In order to let them know the reason in simple language, we
handle exceptions. We handle such conditions and then prints a user-friendly
warning message to user, which lets them correct the error as most of the time
exception occurs due to bad data provided by user.
Advantage of exception handling
Exception handling ensures that the flow of the program doesn’t break when an
exception occurs. For example, if a program has bunch of statements and an exception
occurs mid way after executing certain statements then the statements after the
exception will not execute and the program will
terminate abruptly. By handling we make sure that all the statements
execute and the flow of program doesn’t break.
Difference between error and exception
Errors indicate that something severe enough has gone wrong, the application
should crash rather than try to handle the error.
Exceptions are events that occurs in the code. A programmer can handle such
conditions and take necessary corrective actions. Few examples:
NullPointerException - When you try to use a reference that points to null.
ArithmeticException - When bad data is provided by user, for example, when you try to
divide a number by zero this exception occurs because dividing a number by zero
is undefined.
ArrayIndexOutOfBoundsException - When you try to access the elements of an array
out of its bounds, for example array size is 5 (which means it has five elements) and
you are trying to access the 10th element.

of
Types of exceptions
There are two types of exceptions in
Java: 1.Checked exceptions
2.Unchecked exceptions
Checked exceptions
All exceptions other than Runtime Exceptions are known as Checked exceptions
as the compiler checks them during compilation to see whether the programmer has
handled them or not. If these exceptions are not handled/declared in the program,
you will get compilation error. For example, SQLException, IOException,
ClassNotFoundException etc.
Unchecked Exceptions
Runtime Exceptions are also known as Unchecked Exceptions. These exceptions
are not checked at compile-time so compiler does not check whether the programmer
has handled them or not but it’s the responsibility of the programmer to handle these
exceptions and provide a safe exit. For example, ArithmeticException,
NullPointerException, ArrayIndexOutOfBoundsException etc.
Try Catch in Java – Exception handling
Try-catch block is used for exception handling.
Try block
The try block contains set of statements where an exception can occur. A try
block is always followed by a catch block, which handles the exception that occurs
in associated try block. A try block must be followed by catch blocks or finally block
or both.
Syntax of try block
try{
//statements that may cause an exception
}
While writing a program, if you think that certain statements in a program can
throw a exception, enclosed them in try block and handle that exception.

of
Catch block
A catch block is where you handle the exceptions, this block must follow the try
block. A single try block can have several catch blocks associated with it. You can
catch different exceptions in different catch blocks. When an exception occurs in try
block, the corresponding catch block that handles that particular exception
executes. For example, if an arithmetic exception occurs in try block then the
statements enclosed in catch block for arithmetic exception executes.
Syntax of try catch in java
try
{
}
catch(exception(type) e(object))
{
//error handling code
}
Example: try catch block
If an exception occurs in try block, then the control of execution is passed to
the corresponding catch block. A single try block can have multiple catch blocks
associated with it, you should place the catch blocks in such a way that the generic
exception handler catch block is at the last(see in the example below).
The generic exception handler can handle all the exceptions but you should
place is at the end, if you place it at the before all the catch blocks then it will display
the generic message. You always want to give the user a meaningful message for each
type of exception rather than a generic message.
classExample1{
public static void main(String args[])
{ int num1, num2;
try{
/* We suspect that this block of statement can throw
* exception so we handled it by placing these statements
* inside try and handled the exception in catch block
*/
num1 =0;
num2 =62/ num1;
System.out.println(num2);
System.out.println("Hey I'm at the end of try block");
}
catch(ArithmeticException e){
/* This block will only execute if any Arithmetic exception
* occurs in try block
*/
System.out.println("You should not divide a number by zero");
}
catch(Exception e){
/* This is a generic Exception handler which means it can handle

of
* all the exceptions. This will execute if the exception is not
* handled by previous catch blocks.
*/
System.out.println("Exception occurred");
}
System.out.println("I'm out of try-catch block in Java.");
}
}
Output:
You should not divide a number by
zero I'm out of try-catch block in
Java.
Multiple catch blocks in Java
Rules about multiple catch blocks:
1.A single try block can have any number of catch blocks.
2.A generic catch block can handle all the exceptions. Whether it is Array Index Out Of
Bounds Exception or Arithmetic Exception or Null Pointer Exception or any other type
of exception, this handles all of them. To see the examples of NullPointerException
and ArrayIndexOutOfBoundsException, refer this article:
Exception Handling example programs.
catch(Exception e){
//This catch block catches all the exceptions
}
If you are wondering why we need other catch handlers when we have a generic that
can handle all. This is because in generic exception handler you can display a message
but you are not sure for which type of exception it may trigger so it will display the
same message for all the exceptions and user may not be able to understand which
exception occurred. Thats the reason you should place is at the end of all the
specific exception catch blocks
3.If no exception occurs in try block then the catch blocks are completely ignored.
4. Corresponding catch blocks execute for that specific type of exception:
catch(ArithmeticException e) is a catch block that can handle ArithmeticException
catch(NullPointerException e) is a catch block that can handle
NullPointerException
5. You can also throw exception, which is an advanced topic and I have covered it
in separate tutorials: user defined exception, throws keyword, throw vs throws.
Example of Multiple catch blocks
classExample2{
try{
int a[]=newint[7];
a[4]=30/0;
System.out.println("First print statement in try block");
}
System.out.println("Warning: ArithmeticException");
}

of
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Warning: ArrayIndexOutOfBoundsException");
}
catch(Exception e){
System.out.println("Warning: Some Other exception");
}
System.out.println("Out of try-catch block...");
}
}
Output:
Warning:
ArithmeticException Out of
try-catch block...
In the above example there are multiple catch blocks and these catch blocks
executes sequentially when an exception occurs in try block. Which means if you put
the last catch block ( catch(Exception e)) at the first place, just after try block then in
case of any exception this block will execute as it can handle all exceptions. This catch
block should be placed at the last to avoid such situations.
Finally block
java finally block. executes whether an exception occurs or not. You should
place those statements in finally blocks, that must execute whether exception
occurs or not.
Nested try catch block in Java – Exception handling
When a try catch block is present in another try block then it is called the
nested try catch block. Each time a try block does not have a catch handler for a
particular exception, then the catch blocks of parent try block are inspected for that
exception, if match is found that that catch block executes.
If neither catch block nor parent catch block handles exception then the
system generated message would be shown for the exception, similar to what we see
when we don’thandle exception.
Lets see the syntax first then we will discuss this with an example.
Syntax of Nested try Catch
....
//Main try block
try{
statement 1;
statement 2;
//try-catch block inside another try
block try{
statement 3;
statement 4;
//try-catch block inside nested try
block try{
statement 5;
statement 6;
}
catch(Exception e2){
//Exception Message
}

of
}
//Exception Message
}
}
//Catch of Main(parent) try
block catch(Exception e3){
//Exception Message
}
Nested Try Catch Example
Here we have deep (two level) nesting which means we have a try-catch block
inside a nested try block. To make you understand better I have given the names to
each try block in comments like try-block2, try-block3 etc.
This is how the structure is: try-block3 is inside try-block2 and try-block2 is inside
main try-block, you can say that the main try-block is a grandparent of the try-
block3. Refer the explanation which is given at the end of this code.
classNestingDemo{public static
void main(Stringargs[]){
//main try-
block try{
//try-block2
try{
//try-block3
try{
intarr[]={1,2,3,4};
/* I'm trying to display the value of
* an element which doesn't exist. The
* code should throw an exception
*/
System.out.println(arr[10])
;
}catch(ArithmeticException e){
System.out.print("Arithmetic Exception");
System.out.println(" handled in try-block3");
}
}
System.out.println(" handled in try-block2");
}
}
catch(ArithmeticException e3){
System.out.println(" handled in main try-block");
}
catch(ArrayIndexOutOfBoundsException e4){
System.out.print("ArrayIndexOutOfBoundsException");
System.out.println(" handled in main try-block");
}

of
System.out.print("Exception");
System.out.println(" handled in main try-
block");
}
}
}
Output:
ArrayIndexOutOfBoundsException handled in main try-block
As you can see that the ArrayIndexOutOfBoundsException occurred in the
grandchild try-block3. Since try-block3 is not handling this exception, the control then
gets transferred to the parent try-block2 and looked for the catch handlers in try-
block2. Since the try-block2 is also not handling that exception, the control gets
transferred to the main (grandparent) try- block where it found the appropriate
catch block for exception. This is how the the nesting structure works.
Example 2: Nested try block
classNest{
//Parent try block
try{
try{
//Child try block1
System.out.println("Inside block1");
int b =45/0;
System.out.println(b);
}
System.out.println("Exception: e1");
}
//Child try
block2 try{
System.out.println("Inside block2");
int b =45/0;
System.out.println(b);
}
System.out.println("Exception: e2");
}
System.out.println("Just other statement");
}
System.out.println("Arithmetic Exception");
System.out.println("Inside parent try catch block");
}
System.out.println("ArrayIndexOutOfBoundsException");
}
System.out.println("Exception");

of
}
System.out.println("Next statement..");
}
}
Output:
Inside
block1
Exception:
e1 Inside
block2
ArithmeticException
nside parent trycatch
block Next statement..
This is another example that shows how the nested try block works. You can
see that there are two try-catch block inside main try block’s body. I’ve marked
them as block 1 and block 2 in above example.
Block1: I have divided an integer by zero and it caused an ArithmeticException, since the
catch of block1 is handling ArithmeticException "Exception: e1" displayed.
Block2: In block2, ArithmeticException occurred but block 2 catch is only handling Array
Index Out Of Bounds Exception so in this case control jump to the Main try-
catch(parent) body and checks for the ArithmeticException catch handler in parent
catch blocks. Since catch of parent try block is handling this exception using generic
Exception handler that handles all exceptions, the message “Inside parent try catch block”
displayed as output.
Parent try Catch block: No exception occurred here so the “Next statement.” displayed.
The important point to note here is that whenever the child catch blocks are not
handling any exception, the jumps to the parent catch blocks, if the exception is not
handled there as well then, the program will terminate abruptly showing system
generated message.
Checked and unchecked exceptions in java with examples
There are two types of exceptions: checked exception and unchecked exception.
In this guide, we will discuss them. The main difference between checked and
unchecked exception is that the checked exceptions are checked at compile-time
while unchecked exceptions are checked at runtime.
What are checked exceptions?
Checked exceptions are checked at compile-time. It means if a method is
throwing a checked exception then it should handle the exception using try-catch block
or it should declare the exception using throws keyword, otherwise the program
will give a compilation error.
Lets understand this with the help of an example:
Checked Exception Example
In this example we are reading the file myfile.txt and displaying its content
on the screen. In this program there are three places where a checked exception is
thrown as mentioned in the comments below. FileInputStream which is used for
specifying the file path and name, throws FileNotFoundException. The read() method
which reads the file content throws IOException and the close() method which
closes the file input stream also throws IOException.
import java.io.*;

of
classExample{
{
FileInputStreamfis=null;
/*This constructor FileInputStream(File filename)
* throws FileNotFoundException which is a checked
* exception
*/
fis=newFileInputStream("B:/myfile.txt");
int k;
/* Method read() of FileInputStream class also throws
* a checked exception: IOException
*/
while(( k =fis.read())!=-1)
{
System.out.print((char)k);
}
/*The method close() closes the file input stream
* It throws
IOException*/
fis.close();
}
}
Output:
Exceptionin thread "main"java.lang.Error:Unresolved compilation problems:
Unhandled exception type FileNotFoundException
Unhandled exception type
IOException Unhandled exception
type IOException
Why this compilation error?
As I mentioned in the beginning that checked exceptions gets checked during
compile time. Since, we didn’t handled/declared the exceptions, our program gave the
compilation error.
How to resolve the error?
There are two ways to avoid this error. We will see both the ways one by one.
Method 1: Declare the exception using throws keyword.
As we know that all three occurrences of checked exceptions are inside main()
method so one way to avoid the compilation error is: Declare the exception in the
method using throws keyword. You may be thinking that our code is throwing
FileNotFoundException and IOException both then why we are declaring the
IOException alone. The reason is that IOException is a parent class of
FileNotFoundException so it by default covers that. If you want you can declare them
like this public static void main(String args[]) throws IOException,
FileNotFoundException.
import java.io.*;
classExample{
publicstaticvoid main(Stringargs[])throwsIOException

of
{
fis=newFileInputStream("B:/myfile.txt")
; int k;
{
}
fis.close();
}
}
Output:
File content is displayed on the screen.
Method 2: Handle them using try-catch blocks.
The approach we have used above is not good at all. It is not the best
exception handling practice. You should give meaningful message for each exception
type so that it would be easy for someone to understand the error. The code should
be like this:
import java.io.*;
class Example{
{
try{
fis=newFileInputStream("B:/myfile.txt")
;
}catch(FileNotFoundExceptionfnfe)
{ System.out.println("The specified file is
not "+
"present at the given path");
}
int k;
try{
{
}
fis.close();
}catch(IOExceptionioe){
System.out.println("I/O error occurred: "+ioe);
}
}
}
This code will run fine and will display the file content.
Here are the few other Checked Exceptions –
 SQLException
 IOException
 ClassNotFoundException
 InvocationTargetException

of
What are Unchecked exceptions?
Unchecked exceptions are not checked at compile time. It means if your
program is throwing an unchecked exception and even if you didn’t handle/declare
that exception, the program won’t give a compilation error. Most of the times these
exception occurs due to the bad data provided by user during the user-program
interaction. It is up to the programmer to judge the conditions in advance, that can
cause such exceptions and handle them appropriately. All Unchecked exceptions
are direct sub classes of RuntimeException class.
Lets understand this with an example:
Unchecked Exception Example
Class Example{
Public tatic oid main(String args[])
{
int num1=10;
int num2=0;
/*Since I'm dividing an integer with 0
* it should throw ArithmeticException
*/
int res=num1/num2;
System.out.println(res);
}
}
If you compile this code, it would compile successfully however when you will run it, it would
throw ArithmeticException. That clearly shows that unchecked exceptions are not
checked at compile-time, they occurs at runtime. Lets see another example.
classExample{
{
intarr[]={1,2,3,4,5};
/* My array has only 5 elements but we are trying to
* display the value of 8th element. It should throw
* ArrayIndexOutOfBoundsException
*/
System.out.println(arr[7]);
}
}
This code would also compile successfully since Array Index Out Of Bounds Exception is also
an
unchecked exception.
Note: It doesn’t mean that compiler is not checking these exceptions so we shouldn’t
handle them. In fact we should handle them more carefully. For e.g. In the above
example there should be a exception message to user that they are trying to display a
value which doesn’t exist in array so that user would be able to correct the issue.
Class Example{
Public static void main(String
args[]){ try{
int arr[]={1,2,3,4,5};
System.out.println(arr[7]);
}

of
System.out.println("The specified index does not exist
"+ "in array. Please correct the error.");
}
}
}
Output:
The specified index does not exist in array.Please correct the error.
Here are the few unchecked exception classes:
a. NullPointerException
b. ArrayIndexOutOfBoundsException
c. ArithmeticException
d. IllegalArgumentException
e. NumberFormatException
Java Finally block – Exception handling
A finally block contains all the crucial statements that must be executed
whether exception occurs or not. The statements present in this block will always
execute regardless of whether exception occurs in try block or not such as closing a
connection, stream etc.
Syntax of Finally block
try{
//Statements that may cause an exception
}
catch{
//Handling exception
}
finally{
//Statements to be executed
}
A Simple Example of finally block
Here you can see that the exception occurred in try block which has been
handled in catch block, after that finally block got executed.
Class Example
{
try{
intnum=121/0;
System.out.println(num);
}
System.out.println("Number should not be divided by zero");
}
/* Finally block will always execute
* even if there is no exception in try block
*/
finally
{
System.out.println("This is finally block");
}
System.out.println("Out of try-catch-finally");
}

of
}
Output:
Number should not be divided by
zero Thisisfinally block
Out of try-catch-finally
Few Important points regarding finally block
1. A finally block must be associated with a try block, you cannot use finally without a
try block. You should place those statements in this block that must be executed
always.
2. Finally block is optional, as we have seen in previous tutorials that a try-catch
block is sufficient for exception handling, however if you place a finally block then
it will always run after the execution of try block.
3. In normal case when there is no exception in try block then the finally block is
executed after try block. However if an exception occurs then the catch block is
executed before finally block.
4. An exception in the finally block, behaves exactly like any other exception.
5. The statements present in the finally block execute even if the try block contains
control transfer statements like return, break
or continue. Lets see an example to see how finally works when return
statement is present in try block:
Another example of finally block and return statement.
You can see that even though we have return statement in the method, the
finally block still runs.
Class Java Finally
{
Public static void main(String args[])
{
System.out.println(JavaFinally.myMethod());
}
Public static int myMethod()
{
try{
return112;
}
finally{
System.out.println("This is Finally block");
System.out.println("Finally block ran even after return
statement");
}
}
}
Output of above program:
This is Finally block
Finally block ran even after return
statement 112
Cases when the finally block doesn’t execute
The circumstances that prevent execution of the code in a finally block are:

of
Finally and Close()
CHAPTER – VII
FINALLY () & CLOSE () STATEMENT
close() statement is used to close all the open streams in a program. It’s a good
practice to use close() inside finally block. Since finally block executes even if exception
occurs so you can be sure that all input and output streams are closed properly
regardless of whether the exception occurs or not.
For example:
....
try{
OutputStreamosf=newFileOutputStream("filename");
OutputStreamosb=newBufferedOutputStream(opf);
ObjectOutput op =newObjectOutputStream(osb);
try{
output.writeObject(writableObject);
}
finally{
op.close();
}
}
catch(IOException e1)
{ System.out.println(e1);
}
...
Finally block without catch
A try-finally block is possible without catch block. Which means a try block can be
used with finally without having a catch block.
...
InputStream input
=null; try{
input =newFileInputStream("inputfile.txt");
}
finally{
if(input !=null){
try{
in.close();
}catch(IOExceptionexp)
{ System.out.println(exp);
}
}
}
Finally block and System.exit()
System.exit() statement behaves differently than return statement. Unlike
return statement whenever System.exit() gets called in try block then Finally block doesn’t
execute. Here is a code snippet that demonstrate the same:
....
try{
//try block

of
System.out.println("Inside try block");
System.exit(0)
}
catch(Exceptionexp){
System.out.println(exp);
}
finally{
System.out.println("Java finally block");
}
....
In the above example if the System.exit(0) gets called without any exception then finally
won’t execute. However, if any exception occurs while calling System.exit(0) then finally
block will be executed.
Try-catch-finally block
 Either a try statement should be associated with a catch block or with finally.
 Since catch performs exception handling and finally performs the cleanup, the
best approach is to use both of them.
Syntax:
try{
}
catch(…){
//error handling code
}
finally{
//statements to be executed
}
Examples of Try catch finally blocks
Example 1: The following example demonstrate the working of finally block when no
exception occurs in try block
Class Example1{
Publicstatic void main(String args[])
{ try{
System.out.println("First statement of try block");
intnum=45/3;
}
}
finally{
System.out.println("finally block");
}
System.out.println("Out of try-catch-finally block");
}
}

of
Output:
First statement of try
block 15
finally block
Out of try-catch-finally block
Example 2: This example shows the working of finally block when an exception
occurs in try block but is not handled in the catch block:
Class Example2{
try{
intnum=45/0;
}
}
finally{
}
}
}
Output:
First statement of try
block finally block
Exceptionin thread "main"java.lang.ArithmeticException:/by
zero at
beginnersbook.com.Example2.main(Details.java:6)
As you can see that the system generated exception message is shown but before
that the finally block successfully executed.
Example 3: When exception occurs in try block and handled properly in catch
block Class Example3{
try{
intnum=45/0;
}
System.out.println("ArithmeticException");
}
finally{
}
}
}
Output:

of
First statement of try block
ArithmeticException
finally block
Out of try-catch-finally block
Flow of control in try/catch blocks:
When exception doesn’t occur:
When the statements that are present in try block doesn’t throw any exception
then first, the body of try block executes and then the code after catch blocks. In
this case catch block never runs as they are meant to run when an exception
occurs. For example-
classExample1
{
{
int x =10;
int y
=10; try{
intnum= x/y;
System.out.println("next-statement: Inside try block");
}
catch(Exception
ex)
{
System.out.println("Exception");
}
System.out.println("next-statement: Outside of try-catch");
}
}
Output:
next-statement:Insidetry block
next-statement:Outside of try-catch
In the above example exception didn’t occur in try block so catch block didn’t run.
When exception occurs:
First have a look at the example below and then we will discuss the output:
classExample1
{
publicstaticvoid main(String args[])
{
int x =0;
int y
=10; try{
intnum= y/x;
System.out.println("next-statement: Inside try block");
}
catch(Exception
ex)
{

of
}
}
Output:
System.out.println("Exception Occurred");
}
System.out.println("next-statement: Outside of try-catch");
ExceptionOccurred
next-statement:Outside of try-catch
Point to note in above example: There are two statements present inside try block.
Since exception occurred because of first statement, the second statement didn’t execute.
Hence we can conclude that if an exception occurs then the rest of the try block doesn’t
execute and control passes to catch block.
Flow of control in try/catch/finally blocks:
1. If exception occurs in try block’s body then control immediately
transferred(skipping rest of the statements in try block) to the catch block. Once
catch block finished execution then finally block and after that rest of the
program.
2. If there is no exception occurred in the code which is present in try block then
first, the try block gets executed completely and then control gets transferred
to finally block (skipping catch blocks).
3. If a return statement is encountered either in try or catch block. In this case
finally block runs. Control first jumps to finally and then it returned back to
return statement.
Lets see this example to understand the above mentioned points:
Class TestExceptions{
Staticvoid myMethod(inttestnum)throwsException{
System.out.println("start - myMethod");
if(testnum==12)
thrownewException();
System.out.println("end -
myMethod"); return;
}
inttestnum=12;
try{
System.out.println("try - first statement");
myMethod(testnum);
System.out.println("try - last
statement");
}
catch(Exception ex){
System.out.println("An Exception");
}
finally{
System.out.println("finally");
}
System.out.println("Out of try/catch/finally - statement");
}
}
Output:

of
try- first statement
start -
myMethod
AnException
finally
Out of try/catch/finally- statement

of
CHAPTER – VIII
THROW EXCEPTION IN JAVA
How to throw exception in java with example
In Java we have already defined exception classes such as Arithmetic Exception,
Null Pointer Exception, Array Index Out of Bounds exception etc. These exceptions are
set to trigger on different-2 conditions. For example, when we divide a number by
zero, this triggers Arithmetic Exception, when we try to access the array element
out of its bounds then we get Array Index Out of Bounds Exception.
We can define our own set of conditions or rules and throw an exception
explicitly using throw keyword. For example, we can throw Arithmetic Exception when
we divide number by 5, or any other numbers, what we need to do is just set the
condition and throw any exception using throw keyword. Throw keyword can also be
used for throwing custom exceptions, I have covered that in a separate tutorial, see
Custom Exceptions in Java.
Syntax of throw keyword:
Thrownewexception_class("error message");
For example:
thrownewArithmeticException("dividing a number by 5 is not allowed in this program");
Example of throw keyword
Lets say we have a requirement where we we need to only register the students
when their age is less than 12 and weight is less than 40, if any of the condition is
not met then the user should get an ArithmeticException with the warning message
“Student is not eligible for registration”. We have implemented the logic by placing the
code in the method that checks student eligibility if the entered student age and weight
doesn’t met the criteria then we throw the exception using throw keyword.
/* In this program we are checking the Student age
* if the student age<12 and weight <40 then our program
* should return that the student is not eligible for registration.
*/
Public class ThrowExample{
staticvoid checkEligibilty(intstuage,intstuweight){
if(stuage<12&&stuweight<40){
thrownewArithmeticException("Student is not eligible for registration");
}
else{
System.out.println("Student Entry is Valid!!");
}
}
System.out.println("Welcome to the Registration process!!");
checkEligibilty(10,39);
System.out.println("Have a nice day..");
}
}
Output:

of
Welcome to the Registration process!!Exceptionin thread "main"
java.lang.ArithmeticException:Studentisnot eligible for registration
at
beginnersbook.com.ThrowExample.checkEligibilty(ThrowExample.java:9)
at beginnersbook.com.ThrowExample.main(ThrowExample.java:18)
In the above example we have throw an unchecked exception, same way we can
throw uncheckedand user-defined exception as well.
Throw Keyword Example in Java
Here, various examples to demonstrate how to throw an exception using
throw keyword. To understand these programs, you should have the basic knowledge
of what is throw keyword and why we throw exception using throw keyword, refer
this guide: throw in java.
Example 1: How to throw your own exception explicitly using throw keyword
This example shows how to throw a custom exception using throw. Refer this guide to
understand how to create your own exceptions.
classMyOwnExceptionextendsException{
publicMyOwnException(Stringmsg){
super(msg);
}
}
Class EmployeeTest{
staticvoidemployeeAge(int age) throws
MyOwnException{ if(age <0)
thrownewMyOwnException("Age can't be less than
zero"); else
System.out.println("Input is valid!!");
}
publicstaticvoid main(String[]args){
try{
employeeAge(-2);
}
catch(MyOwnException e){
e.printStackTrace();
}
}
}
Output:
beginnersbook.com.MyOwnException:Age can't be less than zero
Note: Method call should be in try block as it is throwing an exception.
Example2: How to throw an already defined exception using throw keyword
Class Exception2{
staticint sum(int num1,int num2){
if(num1 ==0)
thrownewArithmeticException("First parameter is not valid");
else
System.out.println("Both parameters are correct!!");
return num1+num2;
}

of
int res=sum(0,12);
System.out.println(res);
System.out.println("Continue Next statements");
}
}
Output:
Exceptionin thread main java.lang.ArithmeticException:
First parameter isnot valid
Similarly other exceptions, such as NullPointerException, ArrayIndexOutOfBoundsException
etc. can be thrown.
Throws Keyword Example in Java
Here we will see few examples of throws keyword. To understand these
programs, you should have the knowledge of throws keyword in java.
Example 1: Exception propagation using throws keyword
As you can see that we have an exception occurred in method1 which has been
handled in the chain-calling method method3(). This example shows how exception
propagation works. classExample1{
void method1()throwsArithmeticException{
thrownewArithmeticException("Calculation error");
}
void method2()throwsArithmeticException{
method1();
}
void method3(){
try{
method2();
}
System.out.println("ArithmeticException handled");
}
}
{ Example1obj=newExample1();
obj.method3();
System.out.println("End Of
Program");
}
}
Output:
Arithmetic Exception
handled End of Program
Example 2: When you don’t handle exception and instead declare it at all the places
The ideal way to use throws is by declaring the exceptions in method
signature and handle the exceptions using try-catch in calling method. Lets see
what happens when we declare the exception at both the places, in method
signature as well as in calling method.
Class Exception Example{

of
void method()throws Arithmetic Exception{
thrownew Arithmetic Exception("Arithmetic Exception Occurred");
}
}
Class Example1{
Public static void main(String args[]) throws ArithmeticException{
ExceptionExampleobj=newExceptionExample();
obj.method();
System.out.println("End Of Program");
}
}
Output:
Exceptionin thread "main"java.lang.ArithmeticException:
ArithmeticExceptionOccurred
at
ExceptionExample.method(Example1.java:4)
at Example1.main(Example1.java:10)
Throws clause in java – Exception handling
BY CHAITANYA SINGH | FILED UNDER: EXCEPTION HANDLING
As we know that there are two types of exception checked and unchecked.
Checked exception (compile time) force you to handle them, if you don’t handle them then
the program will not compile.
On the other hand unchecked exception (Runtime) doesn’t get checked during
compilation. Throws keyword is used for handling checked exceptions. By using throws
we can declare multiple exceptions in one go.
What is the need of having throws keyword when you can handle exception using try-catch?
The throws does the same thing that try-catch does but there are some cases
where you would prefer throws over try-catch. For example:
Lets say we have a method myMethod() that has statements that can throw
either ArithmeticException or NullPointerException, in this case you can use try-
catch as shown below:
publicvoidmyMethod()
{
try{
// Statements that might throw an exception
}
// Exception handling statements
}
catch(NullPointerException e){
}
}
But suppose you have several such methods that can cause exceptions, in that case it
would be tedious to write these try-catch for each method. The code will become
unnecessary long and will be less-readable.

of
One way to overcome this problem is by using throws like this: declare the exceptions
in
the method signature using throws and handle the exceptions where you are
calling this method by using try-catch.
Another advantage of using this approach is that you will be forced to
handle the exception when you call this method, all the exceptions that are declared
using throws, must be handled where you are calling this method else you will get
compilation error.
publicvoidmyMethod () throwsArithmeticException, NullPointerException
{
// Statements that might throw an exception
}
try{
myMethod();
}
}
catch(NullPointerException e){
}
}
Example of throws Keyword
In this example the method myMethod() is throwing two checked exceptions
so we have declared these exceptions in the method signature using throws Keyword.
If we do not declare these exceptions then the program will throw a compilation
error.
import java.io.*;
classThrowExampl
e{
voidmyMethod(intnum)throwsIOException,ClassNotFoundException{
if(num==1)
thrownewIOException("IOException Occurred");
else
thrownewClassNotFoundException("ClassNotFoundException");
}
}
publicclassExample1{
try{
ThrowExampleobj=newThrowExample();
obj.myMethod(1);
}catch(Exception ex){
System.out.println(ex);
}
}
}
Output:
java.io.IOException:IOExceptionOccurr
ed
How to Catch multiple exceptions

of
BY CHAITANYA SINGH | FILED UNDER: EXCEPTION HANDLING
Catching multiple exceptions
Lets take an example to understand how to handle multiple
exceptions. classExample{
try{
intarr[]=newint[7];
arr[4]=30/0;
System.out.println("Last Statement of try block");
}
}
System.out.println("Accessing array elements outside of the limit");
}
catch(Exception e){
System.out.println("Some Other
Exception");
}
System.out.println("Out of the try-catch block");
}
}
Output:
You should not divide a number by
zero Out of the try-catch block
In the above example, the first catch block got executed because the code
we have written in try block throws ArithmeticException (because we divided the
number by zero).
Now lets change the code a little bit and see the change in output:
classExample{
try{
intarr[]=newint[7];
arr[10]=10/5;
}
}
}
catch(Exception e){
Exception");
}
}
}
Output:

of
Accessing array elements outside of the limit
Out of the try-catch block
In this case, the second catch block got executed because the code throws Array
Index Out Of Bounds Exception. We are trying to access the 11th element of array in
above program but the array size is only 7.
What did we observe from the above two examples?
1. It is clear that when an exception occurs, the specific catch block (that declares
that exception) executes. This is why in first example first block executed and in second
example second catch.
2. Although I have not shown you above, but if an exception occurs in above code
which is not Arithmetic and ArrayIndexOutOfBounds then the last generic catch
handler would execute.
Lets change the code again and see the output:
Class Example{
Public staticvoid main(String args[])
{ try{
intarr[]=newint[7];
arr[10]=10/5;
}
catch(Exception e){
Exception");
}
}
}
}
}
Output:
Compile time error:Exceptionin thread "main"java.lang.Error:
Unresolved compilation problems:Unreachablecatch block
forArithmeticException. Itis already handled by the catch block
forExceptionUnreachablecatch block
forArrayIndexOutOfBoundsException.Itis already handled by the catch block
for Exception at Example.main.

of
What are Java Threads?
A thread is a:
CHAPTER – IX
INTRODUCTION OF THREADS IN JAVA
a. Facility to allow multiple activities within a single process
b. Referred as lightweight process
c. A thread is a series of executed statements
d. Each thread has its own program counter, stack and local variables
e. A thread is a nested sequence of method calls
f. Its shares memory, files and per-process
state Read: Multithreading in Java
Whats the need of a thread or why we use Threads?
a. To perform asynchronous or background processing
b. Increases the responsiveness of GUI applications
c. Take advantage of multiprocessor systems
d. Simplify program logic when there are multiple independent
entities e.
What happens when a thread is invoked?
When a thread is invoked, there will be two paths of execution. One path will
execute the thread and the other path will follow the statement after the thread
invocation. There will be a separate stack and memory space for each thread.
Risk Factor
a. Proper co-ordination is required between threads accessing common variables
[use of synchronized and volatile] for consistence view of data
b. overuse of java threads can be hazardous to program’s performance and
its maintainability.
Threads in Java
Java threads facility and API is deceptively simple:
Every java program creates at least one thread [ main() thread ]. Additional
threads are created through the Thread constructor or by instantiating classes that
extend the Thread class.
Thread creation in Java
Thread implementation in java can be achieved in two ways:
A. Extending the java.lang.Thread class
B. Implementing the java.lang.Runnable Interface
Note: The Thread and Runnable are available in the java.lang.* package
A.By extending thread class
1. The class should extend Java Thread class.
2. The class should override the run() method.
3. The functionality that is expected by the Thread to be executed is written in
the run() method.
void start(): Creates a new thread and makes it
runnable. void run(): The new thread begins its life inside this method.
Example:
publicclassMyThreadextendsThread{

of
publicvoid run(){
System.out.println("thread is running...");
}
MyThreadobj=newMyThread();
obj.start();
}
B.By Implementing Runnable interface
1. The class should implement the Runnable interface
2. The class should implement the run() method in the Runnable interface
3. The functionality that is expected by the Thread to be executed is put in the
run() method
Example:
Public class MyThreadimplementsRunnable{
publicvoid run(){
System.out.println("thread is running..");
}
publicstaticvoid
main(String[]args){ Thread t
=newThread(newMyThread());
t.start();
}
Extends Thread class vs Implements Runnable Interface?
Extending the Thread class will make your class unable to extend other classes,
because of the single inheritance feature in JAVA. However, this will give you a simpler
code structure. If you implement Runnable, you can gain better object-oriented design
and consistency and also avoid the single inheritance problems.
If you just want to achieve basic functionality of a thread you can simply
implement Runnable interface and override run() method. But if you want to do
something serious with thread object as it has other methods like suspend(), resume(),
..etc which are not available in Runnable interface then you may prefer to extend the
Thread class.
Thread life cycle in java
Read full article at: Thread life cycle in java
Ending Thread
A Thread ends due to the following reasons:
 The thread ends when it comes when the run() method finishes its execution.
 When the thread throws an Exception or Error that is not being caught in the
program.
 Java program completes or ends.
 Another thread calls stop() methods.
Synchronization of Threads
 In many cases concurrently running threads share data and two threads try
to do operations on the same variables at the same time. This often results in
corrupt data as two threads try to operate on the same data.
 A popular solution is to provide some kind of lock primitive. Only one thread can
acquire a particular lock at any particular time. This can be achieved by using
a keyword “synchronized” .

of
 By using the synchronize only one thread can access the method at a time and a
second call will be blocked until the first call returns or wait() is called inside the
synchronized method.
Deadlock
Whenever there is multiple processes contending for exclusive access to
multiple locks, there is the possibility of deadlock. A set of processes or threads is said
to be deadlocked when each is waiting for an action that only one of the
others can perform. In Order to avoid deadlock, one should ensure that when you
acquire multiple locks, you always acquire the locks in the same order in all threads.
Guidelines for synchronization
 Keep blocks short. Synchronized blocks should be short — as short as possible
while still protecting the integrity of related data operations.
 Don’t block. Don’t ever call a method that might block, such as
InputStream.read(), inside a synchronized block or method.
 Don’t invoke methods on other objects while holding a lock. This may sound
extreme, but it eliminates the most common source of deadlock.
Java Main Thread
Once a Java program starts, one thread starts running immediately. This is usually
called main thread of your program, because it is the one which is executed when
your program starts. The main thread is important for the following two reasons:
 It is the thread from which the other (child) threads will be spawned
 Often, it must be the last thread to finish the execution as it performs various
shutdown actions
Although the main thread is automatically created when your program starts, it
can be controlled through a Thread object. To do so, you must obtain a reference
to it by calling the method named currentThread(), is a public static member of the
Thread. Its general form is : static Thread currentThread()
This method returns a reference to the thread in which it is called. And once you
have a reference to the main thread, you can control it just like any other thread.
Java Main Thread Example
Here is an example demonstrates the concept of main thread in Java:
/* Java Program Example - Java Main Thread
* This program control the main Thread
*/
class JavaProgram
{
{
Thread thr = Thread.currentThread();
System.out.println("Current thread : " +
thr);
/* change the name of the thread */

} catch(InterruptedException e) {
System.out.println("Main thread interrupted");
}
}
}
When above java program is compile and executed, it will produce the following output:
In the above program a reference to the current thread (main thread in this case) is
obtained by calling the current thread) method, and this reference is stored in the local variable
between each line. The pause is executed by the sleep() specifies the delay period in milliseconds.
Page 60 of
thr.setName("My Thread");
System.out.println("After name change : " +
thr);
try {
for(int i=5; i>0; i--)
{
System.out.println(i);
Thread.sleep(1000);
}
System.out.println("stopped");
Notice here that the try catch block around this loop. The slep() method in the
thread might throw an interrupted exception. It will happen only if some other
thread wanted to interrupt this sleeping one. This program just prints a message.(as
shown in above program) if it gets interrupted.
Notice that the output produced when the is used as an argument to
println().This displays in order, the name of the thread and its priority and then the
name of its group.

of
By default the name of the main thread is main. And its priority is 5, which is the
default value, and main is also the name of the group of threads to which this thread
belongs to.
A thread group is a data structure that controls the state of a collection of
threads as a whole. After the name of the thread is altered the is again output. This
time the new name of the thread is displayed.
In the above program as you can see sleep() causes the thread from which it is
called to suspend execution for the given period of milliseconds. Its general from
is:
Static void sleep(long milliseconds) 6throws interuptedexception
The number of milliseconds to suspend is given in milliseconds. This method
may throw an interrupted exception.
The sleep() has a second form, shown next, allows you to specify the period in
terms of milliseconds and nanoseconds:
Static void sleep (long milliseconds, Intenanoseconds) throws interrupted exception
This second form of sleep() method is useful only in environments that allow
timing periods as short a nanoseconds.
As the preceding program shows, you can use set name() method to set the name of
a
thread.
You can obtain the name of the thread by calling the method getname() this
method is not shown in the above program but you can try it. These methods are
the members of the thread class and are declared like this:
Final void setname (String thread
Name) final strings get Name ()
Here, Thread name specifies the name of the
thread. Creating a thread in java with
example
Creating a thread in java
To create a thread in java you need to instatiate an object of type thread java
provides two ways to create a thread
A. By implementing the Runnable interface.
B. By extending the thread class.
Here we’ll look at both the ways of creating a thread in java.
A.Implementing Runnable interface
One of the ways to create a thread in java is to implement the Runnable interface.
@functionlinterface

of
InterfaceRunnable
publicabstractvoid();
Note the @Functional interface annotation on the top of the runnable
interface. That is a new annotation added in Java8. Read more about it here Functional
interface annotation in java 8
To implement runnable a class has to implement only the run() method inside
run() method we write the code for the new thread.
When using Runnable you have to explicitly create a thread class object by
passing the Runnable as parameter so that run() method of the thread can be
executed. java thread class defines several constructors, some of the commonly
used are.
Thread()
Thread(String
Name)
Thread(Runnable threadObi)
Thread(Runnable threadObi,String name)
You can use any of the last two in case of runnable to create a thread in java.
After the new thread is created, it will not start running until you call the start()
method, which is declared within thread class. As soon as start() method is called
upon a thread object following actions happen-
 The thread’s state changes from New state to the runnable state.
 Thread’s target run() method will execute (depends upon when thread gets
the CPU CYCLE).
Java Thread creation Example using Runnable
Class MyThread implements Runnable{
@Override
publicvoid run(){
System.out.println("Entered run method
"+Thread.currentThread().getName()); for(int i =0; i <5; i++){
System.out.println("My Thread"+ i);
}
System.out.println("Finished with MyThread");
}
}
publicclassThreadDemo{
// Passing runnable instance
Threadthread=newThread(newMyThread());
// Calling start
method
thread.start();
}
}
Output
Entered run method Thread-0

of
v
My
Thread0
My
Thread1
My
Thread2
My
Thread3
My
Thread4
Finished with MyThread
Here we are using the constructor Thread(Runnable threadObj) while creating a thread
object -
Thread thread = new Thread(new MyThread());.
Calling start() method on the thread will execute the run method where it will print
numbers along with the thread name.
Creating thread by extending Thread class
Another way to create a thread in Java is to create a class that extends Thread class
and then create an instance of that class. The extending class has to override the run()
method and also needs to call start() method to start execution of the new thread.
Thread creation Example by extending Thread
class Class MyThread extends Thread{
@Override
publicvoid run()
{
System.out.println("My Thread"+ i);
}
System.out.println("Finished with MyThread");
}
}
Public class ThreadDemo{
MyThread thread =newMyThread();
thread.start();
}
}
Here we are extending the thread class so we just need to create an instance of that
class that will be a thread object. Then we are calling start() method on that thread
object.
So these are the 2 ways provided in Java to create a new thread.
There are some other ways we can implement the run() method like, as an
anonymous class and starting Java 8 using a lambda expression. Lets see how
that can be done.
Java thread as an anonymous
class classInnerThread{
Thread t;
// Constructor
publicInnerThread(String
name){
// Anonymous class with run method
implemented Thread t =newThread(name){
@Override
publicvoid run()
{

of
System.out.println(name + i);

of
}
System.out.println("Finished with Inner Thread");
}
};
// starting the thread, which will start execution of run
method t.start();
}
}
publicclassThreadDemo{
InnerThread thread =newInnerThread("MyThread");
}
}
Here we are implementing the run method using an anonymous class. Note that
Thread class is not explicitly extended here and the implementation of the run()
method is provided when an instance of the thread is created.
Implementing Runnable as an anonymous class
If you want to do it using runnable interface run() method implementation it will only be
a small change.
classInnerThread{
Thread t;
// Constructor
publicInnerThread(String
name){
// Anonymous class with run method implemented
// using Runnable interface
Thread t =newThread(newRunnable(){
@Override
publicvoid run(){
System.out.println(name + i);
}
System.out.println("Finished with Inner Thread");
}
}, name);// Name of the thread, second param
// starting the thread, which will start execution of run
method t.start();
}
}
Implementing Runnable as Java Lambda expression
Java 8 onward it is also possible to use lambda expression to provide implementation
of the run method of the runnable interface. Runnable interface has a single abstract
method run() thus it can be considered as a functional interface. Lambda
expression can be used to provide implementation of that abstract method.
classLambdaThread{
publicLambdaThread(String
name){
// Lambda block - code inside the lambda block will
// be the implementation of the run
method. Runnable r =()->{

publicclassThreadDemo{ publicstaticvoid main(String[]args){
LambdaThread thread =newLambdaThread("LambdaThread");
}
}
Here we have used the lambda expression to provide implementation of the run method of th
Page 66 of
System.out.println("Lambda thread "+ i);
}
System.out.println("Finished with Lambda Thread");
};
//starting thread with the constructor of the thread class
// that takes runnable instance and String as
parameters newThread(r, name).start();
}
}

of
v
CHAPTER - X
MULTI THREADING
Multithreading in java with examples
Before we talk about multithreading, let’s discuss threads. A thread is a light-
weight smallest part of a process that can run concurrently with the other parts(other
threads) of the same process. Threads are independent because they all have separate
path of execution that’sthe reason if an exception occurs in one thread, it doesn’t affect the
execution of other threads. All threads of a process share the common memory. The
process of executing multiple threads simultaneously is known as multithreading.
Let’s summarize the discussion in points:
1. The main purpose of multithreading is to provide simultaneous execution of two or
more parts of a program to maximum utilize the CPU time. A multithreaded program
contains two or more parts that can run concurrently. Each such part of a program
called thread.
2. Threads are lightweight sub-processes, they share the common memory space.
In Multithreaded environment, programs that are benefited from multithreading,
utilize the maximum CPU time so that the idle time can be kept to minimum.
4. A thread can be in one of the following states:
NEW - A thread that has not yet started is in this state.
RUNNABLE - A thread executing in the Java virtual machine is in this state.
BLOCKED – A thread that is blocked waiting for a monitor lock is in this state.
WAITING – A thread that is waiting indefinitely for another thread to
perform a particular action is in this state.
TIMED_WAITING – A thread that is waiting for another thread to perform an
action for up to a specified waiting time is in this state.
TERMINATED – A thread that has exited is in this state.
A thread can be in only one state at a given point in time.
Multitasking vs Multithreading vs Multiprocessing vs parallel processing
Multitasking: Ability to execute more than one task at the same time is known as
multitasking.
Multithreading: We already discussed about it. It is a process of executing
multiple threads simultaneously. Multithreading is also known as Thread-based
Multitasking.
Multiprocessing: It is same as multitasking, however in multiprocessing more
than one CPUs are involved. On the other hand one CPU is involved in multitasking.
Parallel Processing: It refers to the utilization of multiple CPUs in a single computer
system.
Creating a thread in Java
There are two ways to create a thread in Java:

of
 By extending Thread class.
 By implementing Runnable interface.
Before we begin with the programs(code) of creating threads, let’s have a
look at these methods of Thread class. We have used few of these methods in the
example below.
getName(): It is used for Obtaining a thread’s name
getPriority(): Obtain a thread’s priority
isAlive(): Determine if a thread is still
running join(): Wait for a thread to
terminate
run(): Entry point for the thread
sleep(): suspend a thread for a period of
time start(): start a thread by calling its
run() method
Method 1: Thread creation by extending Thread class
Example 1:
classMultithreadingDemoextendsThread{
publicvoid run(){
System.out.println("My thread is in running state.");
}
MultithreadingDemoobj=newMultithreadingDemo();
obj.start();
}
}
Output:
My thread isin running state.
Example 2:
Class CountextendsThread
{
Count()
{
super("my extending thread");
System.out.println("my thread created"+this);
start();
}
publicvoid run()
{
try
{
for(int i=0;i<10;i++)
{
System.out.println("Printing the count
"+ i); Thread.sleep(1000);
}
}
catch(InterruptedException e)
{
System.out.println("my thread interrupted");

of
}
System.out.println("My thread run is over");
}
}
Class ExtendingExample
{
{
Countcnt=newCount();
try
{
while(cnt.isAlive())
{
System.out.println("Main thread will be alive till the child thread is
live"); Thread.sleep(1500);
}
}
{
}
System.out.println("Main thread's run is over");
}
}
Output:
my thread createdThread[my runnable
thread,5,main] Main thread will be alive till the
child thread is live Printing the count 0
Printing the count 1
Main thread will be alive till the child thread is
live Printing the count 2
mythread run is
over Main thread run
is over
Method 2: Thread creation by implementing Runnable Interface
A Simple Example
Class MultithreadingDemoimplementsRunnable{
publicvoid run(){

of
v
System.out.println("My thread is in running state.");
}
MultithreadingDemoobj=newMultithreadingDemo();
Threadtobj=newThread(obj);
tobj.start();
}
}
Output:
My thread isin running state.
Example Program 2:
Observe the output of this program and try to understand what is
happening in this program. If you have understood the usage of each thread method
then you should not face any issue, understanding this example.
Class CountimplementsRunnable
{
Threadmythread;
Count()
{
mythread=newThread(this,"my runnable thread");
System.out.println("my thread created"+mythread);
mythread.start();
}
publicvoid run()
{
try
{
for(int i=0;i<10;i++)
{
System.out.println("Printing the count
"+ i); Thread.sleep(1000);
}
}
{
System.out.println("my thread interrupted");
}
System.out.println("mythread run is over");
}
}
classRunnableExample
{
{
Countcnt=newCount();
try
{
while(cnt.mythread.isAlive())
{

of
System.out.println("Main thread will be alive till the child thread is
live"); Thread.sleep(1500);
}
}
{
}
System.out.println("Main thread run is over");
}
}
Output:
my thread createdThread[my runnable
thread,5,main] Main thread will be alive till the
child thread is live Printing the count 0
Main thread will be alive till the child thread is live
mythread run is
over Main thread run
is over
Thread priorities
 Thread priorities are the integers which decide how one thread should be
treated with respect to the others.
 Thread priority decides when to switch from one running thread to another,
process is called context switching
 A thread can voluntarily release control and the highest priority thread that is
ready to run is given the CPU.
 A thread can be preempted by a higher priority thread no matter what the
lower priority thread is doing. Whenever a higher priority thread wants to
run it does.
 To set the priority of the thread setPriority() method is used which is a
method of the class Thread Class.
 In place of defining the priority in integers, we
can use MIN_PRIORITY, NORM_PRIORITY or MAX_PRIORITY.

of
v
Methods: isAlive() and
join()
CHAPTER – XI
THREAD METHODS & APPLETS
 In all the practical situations main thread should finish last else other threads
which have spawned from the main thread will also finish.
 To know whether the thread has finished we can call isAlive() on the thread
which returns true if the thread is not finished.
 Another way to achieve this by using join() method, this method when called
from the parent thread makes parent thread wait till child thread terminates.
 These methods are defined in the Thread class.
 We have used isAlive() method in the above examples too.
Synchronization
 Multithreading introduces asynchronous behavior to the programs. If a thread
is writing some data another thread may be reading the same data at that
time. This may bring inconsistency.
 When two or more threads need access to a shared resource there should be
some way that the resource will be used only by one resource at a time. The
process to achieve this is called synchronization.
 To implement the synchronous behavior java has synchronous method. Once a
thread is inside a synchronized method, no other thread can call any other
synchronized method on the same object. All the other threads then wait until
the first thread come out of the synchronized block.
 When we want to synchronize access to objects of a class which was not
designed for the multithreaded access and the code of the method which
needs to be accessed synchronously is not available with us, in this case we
cannot add the synchronized to the appropriate methods. In java we have the
solution for this, put the calls to the methods (which needs to be synchronized)
defined by this class inside a synchronized block in following manner.
Priority of a Thread (Thread Priority):
Each thread have a priority. Priorities are represented by a number between 1 and 10. In
most cases, thread schedular schedules the threads according to their priority (known as
preemptive scheduling).
But it is not guaranteed because it depends on JVM specification that which scheduling it
chooses.
3 constants defined in Thread class:
1. public static int MIN_PRIORITY
2. public static int NORM_PRIORITY
3. public static int MAX_PRIORITY
Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is 1
and the value of MAX_PRIORITY is 10.
Example of priority of a Thread:
1. class TestMultiPriority1 extends Thread{
2. public void run(){
3. System.out.println("running thread name is:"+Thread.currentThread().getName());
4. System.out.println("running thread priority
is:"+Thread.currentThread().getPriority()); 5.
6. }
7. public static void main(String args[]){

of
v
8. TestMultiPriority1 m1=new TestMultiPriority1();
9. TestMultiPriority1 m2=new TestMultiPriority1();
10. m1.setPriority(Thread.MIN_PRIORITY);
11. m2.setPriority(Thread.MAX_PRIORITY);
12. m1.start();
13. m2.start();
14.
15. }
16. }
Test it Now
Output:running thread name is:Thread-0
running thread priority is:10
running thread name
is:Thread-1 running thread
priority is:1
Inter-thread Communication in Java
Prerequisite : Multithreading in Java, Synchronized in Java
What is Polling and what are problems with it?
The process of testing a condition repeatedly till it becomes true is known as polling.
Polling is usually implemented with the help of loops to check whether a particular
condition is true or not. If it is true, certain action is taken. This waste many CPU
cycles and makes the implementation
inefficient.
For example, in a classic queuing problem where one thread is producing data and
other is consuming it.
How Java multi threading tackles this problem?
To avoid polling, Java uses three methods, namely, wait(), notify() and
notifyAll(). All these methods belong to object class as final so that all classes have
them. They must be used within a synchronized block only.
 wait()-It tells the calling thread to give up the lock and go to sleep until some
other thread enters the same monitor and calls notify().
 notify()-It wakes up one single thread that called wait() on the same object. It
should be noted that calling notify() does not actually give up a lock on a
resource.
 notifyAll()-It wakes up all the threads that called wait() on the same object.
A simple Java program to demonstrate the three methods-
This program might only run in offline IDEs as it contains taking input at several points.
filter_none
edit
play_arrow
brightness_4
// Java program to demonstrate inter-thread communication
// (wait(), join() and notify()) in
Java importjava.util.Scanner;
publicclassthreadexample
{
Public static void main(String
args[]) Throws

of
InterruptedException
{
finalPC pc = newPC();
// Create a thread object that calls
pc.produce() Thread t1 =
newThread(newRunnable()
{
@Override
publicvoidrun()
{
try
{
pc.produce();
}
{
}
}
});
// Create another thread object that calls
// pc.consume()
Thread t2 = newThread(newRunnable()
{
@Override
publicvoidrun()
{
try
{
pc.consume();
}
{
}
}
});
// Start both
threads t1.start();
t2.start();
// t1 finishes before
t2 t1.join();
t2.join();
}
// PC (Produce Consumer) class with produce() and

// releases the lock on shared resource wait();
// and waits till some other method invokes notify(). System.out.println("Resumed");
}
}
// Sleeps for some time and waits for a key press. After key
// is pressed, it notifies produce(). publicvoidconsume()throwsInterruptedException
{
// this makes the produce thread to run first. Thread.sleep(1000);
Scanner s = newScanner(System.in);
// synchronized block ensures only one thread
// running at a time. synchronized(this)
{
System.out.println("Waiting for return key."); s.nextLine();
System.out.println("Return key pressed");
// notifies the produce thread that it
// can wake up. notify();
Page 75 of
v
// consume()
methods. Public
static class PC
{
// Prints a string and waits for consume()
publicvoidproduce()throwsInterruptedException
{
// synchronized block ensures only one thread
// running at a
time.
synchronized(this)
{
System.out.println("producer thread running");
// Sleep
Thread.sleep(2000);
}
}
}
}
Output:
producer thread running
Waiting for return key.
Return key pressed
Resumed
As monstrous as it seem0073, it really is a piece of cake if you go through it twice.
1. In the main class a new PC object is created.
2. It runs produce and consume methods of PC object using two different

of
threads namely t1 and t2 and wait for these threads to finish.
Lets understand how our produce and consume method works.
First of all, use of synchronized block ensures that only one thread at a time runs.
Also since there is a sleep method just at the beginning of consume loop, the produce
thread gets a kickstart.
When the wait is called in produce method, it does two things. Firstly it releases the lock
it holds on PC object. Secondly it makes the produce thread to go on a waiting state until all
other threads have terminated, that is it can again acquire a lock on PC object and some
other method wakes it up by invoking notify or notifyAll on the same object.
Therefore we see that as soon as wait is called, the control transfers to consume thread
and it prints -“Waiting for return key”
After we press the return key, consume method invokes notify(). It also does 2 things-
Firstly, unlike wait(), it does not releases the lock on shared resource therefore for getting the
desired result, it is advised to use notify only at the end of your method. Secondly, it
notifies the waiting threads that now they can wake up but only after the current method
terminates.
As you might have observed that even after notifying, the control does not immediately
passes over to the produce thread. The reason for it being that we have called Thread.sleep()
after notify(). As we already know that the consume thread is holding a lock on PC object,
another thread cannot access it until it has released the lock. Hence only a 0fter the
consume thread finishes its sleep time and thereafter terminates by itself, the produce
thread cannot take back the control.
After a 2 second pause, the program terminates to its completion.
If you are still confused as to why we have used notify in consume thread, try
removing it and running your program again. As you must have noticed now that
the program never terminates.
The reason for this is straightforward-When you called wait on produce thread,
it went on waiting and never terminated. Since a program runs till all its threads have
terminated, it runs on and on.
There is a second way round this problem. You can use a second variant of
wait(). void wait(long timeout)
Java Suspend Resume Stop Threads
Sometimes, suspending the execution of a thread is useful. For example, a separate
thread can be used to display the time of day. If user does not want a clock, then its thread
can be suspended. Whatever the case, suspending a thread is a simple matter. Once
suspended, restarting the thread is also a simple matter.
The mechanisms to suspend, resume, and stop threads differ between early versions of
Java,
such as Java 1.0, and modern versions, beginning with Java 2. Prior to Java 2, a program used
the suspend(), resume(), and stop() methods, which are defined by the Thread, to pause,
restart, and stop the execution of a thread. Although these methods seem to be a
perfectly reasonable and convenient approach to managing the execution of threads, they
must not be used for new Java programs.
Java suspend Thread
The suspend() method of Thread class was deprecated by Java 2 several years ago.
This was done because the suspend() can sometimes cause serious system failures.
Assume that a thread has obtained locks on the critical data structures. If that
thread is suspended at that point, those locks are not relinquished. Other threads that may be
waiting for those resources can be deadlocked.
Java resume Thread
The resume() method is also deprecated. It doest not cause problems, but cannot be
used without the suspend() method as its counterpart.

of
Java stop Thread
The stop() method of Thread class, too, was deprecated by Java 2. This was done
because this method can sometimes cause serious system failures.
Assume that a thread is writing to a critically important data structure and
has completed only part of its changes. If that thread is stopped at that point, that data
structure might be left in a corrupted state. The trouble is that, the stop() causes
any lock the calling thread holds to be released. Thus, the corrupted data might be
used by another thread that is waiting on the same lock.
Java suspend resume stop Thread Example
Because you can-not now use the suspend (), resume(), or stop() methods to control a
thread, you might be thinking that no way exists to pause, restart, or terminate a thread. But
fortunately, this is not true. Instead, a thread must be designed so that the run () method
periodically checks to determine whether that thread should suspend, resume, or stop its own
execution. Typically, this is accomplished by establishing a flag variable that indicates the
execution state of the thread. As long as this flag is set to "running", run() method must
continue to let the thread execute. If this variable is set to "suspend", the thread must pause. If
it is set to "stop", the thread must terminate. Of course, a variety of ways exist in which to
write such code, but the central theme will be same for all the programs.
The following example illustrates how wait() and notify() methods that are inherited
from the Object can be used to control the execution of a thread. Let's consider its
operation. The NewThread class contains a boolean instance variable named suspendFlag which is
used to control the execution of the thread. It is initialized to false by the constructor. The
run() method contains a synchronized statement block that checks suspendFlag. If that
variable is true, the wait() method is invoked to suspend the execution of the thread. The
mysuspend() method sets suspendFlag to true. The myresume() method sets suspendFlag to false
and invokes notify() to wake up the thread. Finally, the main() method has been modified to
invoke the mysuspend() and myresume()methods.
class NewThread implements Runnable
{
String name; //name of
thread Thread thr;
booleansuspendFlag;
NewThread(String threadname)
{
name = threadname;
thr = new Thread(this, name);
System.out.println("New thread : " +
thr); suspendFlag = false;
thr.start(); // start the thread
}
/* this is the entry point for
thread */ public void run()
{
try
{
for(int i=12; i>0; i--)
{
System.out.println(name + " : "
+ i); Thread.sleep(200);
synchronized(this)
{
while(suspendFlag)

of
{
wait();
}
}
}
}
{
System.out.println(name + " interrupted");
}
System.out.println(name + " exiting...");
}
synchronized void mysuspend()
{
suspendFlag = true;
}
synchronized void myresume()
{
suspendFlag =
false; notify();
}
}
class SuspendResumeThread
{
{
NewThread obj1 = new
NewThread("One"); NewThread obj2 =
new NewThread("two");
try
{
Thread.sleep(1000);
obj1.mysuspend();
System.out.println("Suspending thread One...");
Thread.sleep(1000);
obj1.myresume();
System.out.println("Resuming thread One...");
obj2.mysuspend();
System.out.println("Suspending thread Two...");
Thread.sleep(1000);
obj2.myresume();
System.out.println("Resuming thread Two...");
}
{
System.out.println("Main thread Interrupted..!!");
}
/* wait for threads to finish
*/ try
{
System.out.println("Waiting for threads to finish...");
obj1.thr.join();

of
obj2.thr.join();
}
{
System.out.println("Main thread Interrupted..!!");
}
System.out.println("Main thread exiting...");
}

001 Core 15 - Java Programming - III Sem-converted.docx

More Related Content

Similar to 001 Core 15 - Java Programming - III Sem-converted.docx

Recently uploaded

001 Core 15 - Java Programming - III Sem-converted.docx