18CS45

MODULE -3: CLASSES, INHERITANCE, EXCEPTIONS

1. CLASSES:

Definition
A class is a template for an object, and defines the data fields and methods of the
object. The class methods provide access to manipulate the data fields. The “data fields”
of an object are often called “instance variables.”

Example Program:

Program to calculate Area of Rectangle

class Rectangle
{
int length; //Data Member or instance Variables
int width;
void getdata(int x,int y) //Method
{
length=x;
width=y;
}
int rectArea() //Method
{
RETURN(LENgth*width);
}
}

class RectangleArea
{
pUBLic static void main(String args[])
{
Rectangle rect1=new Rectangle(); //object creation
rect1.getdata(10,20); //calling methods USing object with dot(.)
int area1=rect1.rectArea();
System.oUT.Println("Area1="+area1);
}
}

Dept. of CSE, BGMIT OOC (Module 3) 1

 18CS45

 After defining a class, it can be used to create objects by instantiating the class.
Each object occupies some memory to hold its instance variables (i.e. its state).
 After an object is created, it can be used to get the desired functionality together
with its class.

Creating instance of a class/Declaring objects:

Rectangle rect1=new Rectangle()

Rectangle rect2=new Rectangle()

 The above two statements declares an object rect1 and rect2 is of type
Rectangle class using new operator , this operator dynamically allocates
memory for an object and returns a refernce to it.in java all class objects must be
dynamically allocated.

We can also declare the object like this:

Rectangle rect1; // declare reference to object.

rect1=new Rectangle() // allocate memory in the Rectangle object.

The Constructors:

 A constructor initializes an object when it is created. It has the same name as its
class and is syntactically similar to a method. However, constructors have no
explicit return type.
 Typically, you will use a constructor to give initial values to the instance variables
defined by the class, or to perform any other startup procedures required to create
a fully formed object.

Dept. of CSE, BGMIT OOC (Module 3) 2

 18CS45

 All classes have constructors, whether you define one or not, because Java
automatically provides a default constructor that initializes all member variables
to zero. However, once you define your own constructor, the default constructor
is no longer used.

Example:

Here is a simple example that uses a constructor:

// A simple constructor.
class MyClass
{
int x;

// Following is the constructor

MyClass()
{
x = 10;
}
}

You would call constructor to initialize objects as follows:

class ConsDemo
{
public static void main(String args[])
{
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}

Dept. of CSE, BGMIT OOC (Module 3) 3

 18CS45

Parameterized Constructor:

 Most often you will need a constructor that accepts one or more
parameters. Parameters are added to a constructor in the same way that
they are added to a method: just declare them inside the parentheses after
the constructor's name.

Example:

Here is a simple example that uses a constructor:

// A simple constructor.
class MyClass
{
int x;

// Following is the Parameterized constructor

MyClass(int i )
{
x = 10;
}
}

You would call constructor to initialize objects as follows:

class ConsDemo
{
public static void main(String args[])
{
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}

This would produce following result:

10 20

Dept. of CSE, BGMIT OOC (Module 3) 4

 18CS45

static keyword

The static keyword is used in java mainly for memory management. We may
apply static keyword with variables, methods, blocks and nested class. The static
keyword belongs to the class than instance of the class.

The static can be:

1. variable (also known as class variable)

2. method (also known as class method)
3. block
4. nested class

static variable

Example Program without static variable

In this example, we have created an instance variable named count which is

incremented in the constructor. Since instance variable gets the memory at the time of
object creation, each object will have the copy of the instance variable, if it is
incremented, it won't reflect to other objects. So each objects will have the value 1 in the
count variable.

class Counter
{
int count=0;//will get memory when instance is created
Counter()
{
count++;
System.out.println(count);
}
}

Class MyPgm
{
public static void main(String args[])
{
Counter c1=new Counter();

Dept. of CSE, BGMIT OOC (Module 3) 5

 18CS45

Counter c2=new Counter();

Counter c3=new Counter();
}
}
Output: 1
1
1

Example Program with static variable

As we have mentioned above, static variable will get the memory only once, if
any object changes the value of the static variable, it will retain its value.

class Counter
{
static int count=0;//will get memory only once and retain its value

Counter()
{
count++;
System.out.println(count);
}
}
Class MyPgm
{
public static void main(String args[])
{
Counter c1=new Counter();
Counter c2=new Counter();
Counter c3=new Counter();
}
}
Output:1
2
3

Dept. of CSE, BGMIT OOC (Module 3) 6

 18CS45

static method

If you apply static keyword with any method, it is known as static method

 A static method belongs to the class rather than object of a class.

 A static method can be invoked without the need for creating an instance of a
class.
 static method can access static data member and can change the value of it.

//Program to get cube of a given number by static method

class Calculate
{
static int cube(int x)
{
return x*x*x;
}
Class MyPgm
{
public static void main(String args[])
{
//calling a method directly with class (without creation of object) int
result=Calculate.cube(5);
System.out.println(result);
}
}

Output:125

this keyword

 this keyword can be used to refer current class instance variable.

 If there is ambiguity between the instance variable and parameter, this

keyword resolves the problem of ambiguity.

Dept. of CSE, BGMIT OOC (Module 3) 7

 18CS45

Understanding the problem withoUT this keyword

Let's understand the problem if we don't use this keyword by the example given below:
class student
{
int id;
String name;

student(int id,String name)

{
id = id;
name = name;
}
void display()
{
System.out.println(id+" "+name);
}
}
Class MyPgm
{
public static void main(String args[])
{
student s1 = new student(111,"Anoop");
student s2 = new student(321,"Arayan");
s1.display();
s2.display();
}
}

Output: 0 null
0 null

In the above example, parameter (formal arguments) and instance variables are same that
is why we are using this keyword to distinguish between local variable and instance
variable.

Dept. of CSE, BGMIT OOC (Module 3) 8

 18CS45

SolUTIOn of the above problem by this keyword

//example of this keyword
class Student
{
int id;
String name;

student(int id,String name)

{
this.id = id;
this.name = name;
}
void display()
{
System.out.println(id+" "+name);
}
}
Class MyPgm
{
public static void main(String args[])
{
Student s1 = new Student(111,"Anoop");
Student s2 = new Student(222,"Aryan");
s1.display();
s2.display();
}
}
Output111 Anoop
222 Aryan

Inner class

 It has access to all variables and methods of Outer class and may refer to them
directly. But the reverse is not true, that is, Outer class cannot directly access
members of Inner class.
 One more important thing to notice about an Inner class is that it can be created
only within the scope of Outer class. Java compiler generates an error if any
code outside Outer class attempts to instantiate Inner class.

Dept. of CSE, BGMIT OOC (Module 3) 9

 18CS45

Example of Inner class

class Outer
{
public void display()
{
Inner in=new Inner();
in.show();
}

class Inner
{
public void show()
{
System.out.println("Inside inner");
}
}
}

class Test
{
public static void main(String[] args)
{
Outer ot=new Outer();
} ot.display();
}

Output:
Inside inner

Garbage Collection

In Java destruction of object from memory is done automatically by the JVM. When
there is no reference to an object, then that object is assumed to be no longer needed and
the memories occupied by the object are released. This technique is called Garbage
Collection. This is accomplished by the JVM.

Dept. of CSE, BGMIT OOC (Module 3) 10

 18CS45

Can the Garbage Collection be forced explicitly?

No, the Garbage Collection cannot be forced explicitly. We may request JVM for
garbage collection by calling System.gc() method. But this does not guarantee that JVM
will perform the garbage collection.

Advantages of Garbage Collection

1. Programmer doesn't need to worry about dereferencing an object.

2. It is done automatically by JVM.

3. Increases memory efficiency and decreases the chances for memory leak.

finalize() method

Sometime an object will need to perform some specific task before it is destroyed such as
closing an open connection or releasing any resources held. To handle such situation
finalize() method is used. finalize() method is called by garbage collection thread before
collecting object. It’s the last chance for any object to perform cleanup utility.

Signature of finalize() method

protected void finalize()

{
//finalize-code
}

Dept. of CSE, BGMIT OOC (Module 3) 11

 18CS45

gc() Method

gc() method is used to call garbage collector explicitly. However gc() method does not
guarantee that JVM will perform the garbage collection. It only requests the JVM for
garbage collection. This method is present in System and Runtime class.

Example for gc() method

public class Test
{

public static void main(String[] args)

{
Test t = new Test();
t=null;
System.gc();
}
public void finalize()
{
System.out.println("Garbage Collected");
}
}

Output :

Garbage Collected

Dept. of CSE, BGMIT OOC (Module 3) 12

 18CS45

Inheritance:

 As the name suggests, inheritance means to take something that is already

made. It is one of the most important features of Object Oriented
Programming. It is the concept that is used for reusability purpose.
 Inheritance is the mechanism through which we can derive classes from
other classes.
 The derived class is called as child class or the subclass or we can say the
extended class and the class from which we are deriving the subclass is
called the base class or the parent class.
 To derive a class in java the keyword extends is used. The following
kinds of inheritance are there in java.

Types of Inheritance

1. Single level/Simple Inheritance

2. Multilevel Inheritance
3. Multiple Inheritance (Java doesn’t support Multiple inheritance but we
can achieve this through the concept of Interface.)

Pictorial Representation of Simple and Multilevel Inheritance

Simple Inheritance Multilevel Inheritance

Dept. of CSE, BGMIT OOC (Module 3) 13

 18CS45

Single level/Simple Inheritance

 When a subclass is derived simply from its parent class then this mechanism is
known as simple inheritance. In case of simple inheritance there is only a sub
class and its parent class. It is also called single inheritance or one level
inheritance.

Example

class A
{
int x;
int y;
int get(int p, int q)
{
x=p;
y=q;
return(0);
}
void Show()
{
System.out.println(x);
}
}
class B extends A
{
public static void main(String args[])
{
A a = new A();
a.get(5,6);
a.Show();
}
void display()
{
System.out.println("y"); //inherited “y” from class A
}
}

Dept. of CSE, BGMIT OOC (Module 3) 14

 18CS45

 The syntax for creating a subclass is simple. At the beginning of your class
declaration, use the extends keyword, followed by the name of the class to inherit
from:

class A
{

class B extends A //B is a subclass of super class A.

{

Multilevel Inheritance

 When a subclass is derived from a derived class then this mechanism is known as
the multilevel inheritance.
 The derived class is called the subclass or child class for it's parent class and this
parent class works as the child class for it's just above ( parent ) class.
 Multilevel inheritance can go up to any number of level.

class A
{
int x;
int y;
int get(int p, int q)
{
x=p;
y=q;
return(0);
}
void Show()
{
System.out.println(x);
}
}

Dept. of CSE, BGMIT OOC (Module 3) 15

 18CS45

class B extends A
{
void Showb()
{
System.out.println("B");
}
}

class C extends B
{
void display()
{
System.out.println("C");
}
public static void main(String args[])
{
A a = new A();
a.get(5,6);
a.Show();
}
}
OUTPUT
5

Multiple Inheritance

 The mechanism of inheriting the features of more than one base class into a single
class is known as multiple inheritance. Java does not support multiple inheritance
but the multiple inheritance can be achieved by using the interface.

 Here you can derive a class from any number of base classes. Deriving a class
from more than one direct base class is called multiple inheritance.

Dept. of CSE, BGMIT OOC (Module 3) 16

 18CS45

Java does not support multiple Inheritance

In Java Multiple Inheritance can be achieved through use of Interfaces by

implementing more than one interfaces in a class.

super keyword

 The super is java keyword. As the name suggest super is used to access the
members of the super class. It is used for two purposes in java.
 The first use of keyword super is to access the hidden data variables of the super
class hidden by the sub class.

Example: Suppose class A is the super class that has two instance variables as int
a and float b. class B is the subclass that also contains its own data members named a and
b. then we can access the super class (class A) variables a and b inside the subclass class
B just by calling the following command.

super.member;

 Here member can either be an instance variable or a method. This form of super
most useful to handle situations where the local members of a subclass hides the
members of a super class having the same name. The following example clarifies
all the confusions.

Dept. of CSE, BGMIT OOC (Module 3) 17

 18CS45

Example:

class A
{
int a;
float b;
void Show()
{
System.out.println("b in super class: " + b);
}

}
class B extends A
{
int a;
float b;
B( int p, float q)
{
a = p;
super.b = q;
}
void Show()
{
super.Show();
System.out.println("b in super class: " + super.b);
System.out.println("a in sub class: " + a);
}
}

class Mypgm
{
public static void main(String[] args)
{
B subobj = new B(1, 5);
subobj.Show();
}
}
OUTPUT
b in super class: 5.0
b in super class: 5.0
a in sub class: 1

Dept. of CSE, BGMIT OOC (Module 3) 18

 18CS45

Use of super to call super class constructor: The second use of the keyword super in
java is to call super class constructor in the subclass. This functionality can be achieved
just by using the following command.

super(param-list);

 Here parameter list is the list of the parameter requires by the constructor in the
super class. super must be the first statement executed inside a super class
constructor. If we want to call the default constructor then we pass the empty
parameter list. The following program illustrates the use of the super keyword to
call a super class constructor.

Example:

class A
{
int a;
int b;
int c;
A(int p, int q, int r)
{
a=p;
b=q;
c=r;
}
}

class B extends A
{
int d;
B(int l, int m, int n, int o)
{
super(l,m,n);
d=o;
}

void Show()

Dept. of CSE, BGMIT OOC (Module 3) 19

 18CS45

{
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
}
}
class Mypgm
{
public static void main(String args[])
{
B b = new B(4,3,8,7);
b.Show();
}
}
OUTPUT
a=4
b=3
c=8
d=7

Method Overriding

 Method overriding in java means a subclass method overriding a super class

method.
 Superclass method should be non-static. Subclass uses extends keyword to
extend the super class. In the example class B is the sub class and class A is the
super class. In overriding methods of both subclass and superclass possess
same signatures. Overriding is used in modifying the methods of the super class.
In overriding return types and constructor parameters of methods should match.

Below example illustrates method overriding in java.

Example:

Dept. of CSE, BGMIT OOC (Module 3) 20

 18CS45

class A
{
int i;
A(int a, int b)
{
i = a+b;
}
void add()
{
System.out.println("Sum of a and b is: " + i);
}
}
class B extends A
{
int j;
B(int a, int b, int c)
{
super(a, b);
j = a+b+c;
}
void add()
{
super.add();
System.out.println("Sum of a, b and c is: " + j);
}
}
class MethodOverriding
{
public static void main(String args[])
{
B b = new B(10, 20, 30);
b.add();
}
}
OUTPUT
Sum of a and b is: 30
Sum of a, b and c is: 60

Dept. of CSE, BGMIT OOC (Module 3) 21

 18CS45

Method Overloading

 Two or more methods have the same names but different argument lists. The
arguments may differ in type or number, or both. However, the return types of
overloaded methods can be the same or different is called method overloading.
An example of the method overloading is given below:

Example:

class MethodOverloading
{
int add( int a,int b)
{
return(a+b);
}
float add(float a,float b)
{
return(a+b);
}
double add( int a, double b,double c)
{
return(a+b+c);
}
}
class MainClass
{
public static void main( String arr[] )
{
MethodOverloading mobj = new MethodOverloading ();
System.out.println(mobj.add(50,60));
System.out.println(mobj.add(3.5f,2.5f));
System.out.println(mobj.add(10,30.5,10.5));
}
}
OUTPUT
110
6.0
51.0

Dept. of CSE, BGMIT OOC (Module 3) 22

 18CS45

Abstract Class

 abstract keyword is used to make a class abstract.

 Abstract class can’t be instantiated with new operator.
 We can use abstract keyword to create an abstract method; an abstract method
doesn’t have body.
 If classes have abstract methods, then the class also needs to be made abstract
using abstract keyword, else it will not compile.
 Abstract classes are used to provide common method implementation to all the
subclasses or to provide default implementation.

Example Program:

abstract Class AreaPgm

{
double dim1,dim2;
AreaPgm(double x,double y)
{
dim1=x
;
dim2=y
;
}
abstract double area();
}
class rectangle extends AreaPgm
{
rectangle(double a,double b)
{
super(a,b);
}
double area()
{
System.out.println("Rectangle Area");
return dim1*dim2;
}
}
class triangle extends figure
{
triangle(double x,double y)
{
super(x,y);

Dept. of CSE, BGMIT OOC (Module 3) 23

 18CS45

}
double area()
{
System.out.println("Traingle Area");
return dim1*dim2/2;
}
}
class MyPgm
{
public static void main(String args[])
{

AreaPgm a=new AreaPgm(10,10); // error, AreaPgm is a abstract class.

rectangle r=new rectangle(10,5);

System.out.println("Area="+r.area());

triangle t=new triangle(10,8);

AreaPgm ar;
ar=obj;
System.out.println("Area="+ar.area());
}
}

final Keyword In Java

The final keyword in java is used to restrict the user. The final keyword can be used in
many context. Final can be:

1. variable
2. method
3. class

1) final variable: If you make any variable as final, you cannot change the value of final
variable(It will be constant).

Example: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.

Dept. of CSE, BGMIT OOC (Module 3) 24

 18CS45

class Bike
{
final int speedlimit=90;//final variable
void run()
{
speedlimit=400;
}
}
Class MyPgm
{
public static void main(String args[])
{
Bike obj=new Bike();
obj.run();
}
}
Output:Compile Time Error

2) final method: If you make any method as final, you cannot override it.

Example:

class Bike
{
final void run()
{
System.out.println("running");
}
}
class Honda extends Bike
{
void run()
{
System.out.println("running safely with 100kmph");
}
}

Dept. of CSE, BGMIT OOC (Module 3) 25

 18CS45

Class MyPgm
{
public static void main(String args[])
{
Honda honda= new Honda();
honda.run();
}
}
Output:Compile Time Error

3) final class:If you make any class as final, you cannot extend it.

Example:

final class Bike

{

class Honda extends Bike

{
void run()
{
System.out.println("running safely with 50kmph");
}
}

Class MyPgm
{

public static void main(String args[])

{
Honda honda= new Honda();
honda.run();
}
}
Output:Compile Time Error

Dept. of CSE, BGMIT OOC (Module 3) 26

 18CS45

Exception handling:

Introduction

An Exception, It can be defined as an abnormal event that occurs during program

execution and disrupts the normal flow of instructions. The abnormal event can be

an error in the program.

Errors in a java program are categorized into two groups:

1. Compile-time errors occur when you do not follow the syntax of a

programming language.

2. Run-time errors occur during the execution of a program.

Concepts of Exceptions

An exception is a run-time error that occurs during the exception of a java

program.

Example: If you divide a number by zero or open a file that does not exist, an

exception is raised.

In java, exceptions can be handled either by the java run-time system or by a user-

defined code. When a run-time error occurs, an exception is thrown.

The unexpected situations that may occur during program execution are:

 Running out of memory

 Resource allocation errors

 Inability to find files

 Problems in network connectivity

Dept. of CSE, BGMIT OOC (Module 3) 27

 18CS45

Dept. of CSE, BGMIT OOC (Module 3) 28

 18CS45

Exception handling techniques:

Java exception handling is managed via five keywords they are:

1. try:

2. catch.

3. throw.

4. throws.

5. finally.

Exception handling Statement Syntax

Exceptions are handled using a try-catch-finally construct, which has the Syntax.

try
{
<code>
}
catch (<exception type1> <parameter1>)
{
// 0 or more<statements>

}
finally
{
// finally block<statements>
}

1. try Block: The java code that you think may produce an exception is placed
within a try block for a suitable catch block to handle the error.

If no exception occurs the execution proceeds with the finally block else it will
look for the matching catch block to handle the error.

Dept. of CSE, BGMIT OOC (Module 3) 29

 18CS45

Again if the matching catch handler is not found execution proceeds with the
finally block and the default exception handler throws an exception.

2. catch Block: Exceptions thrown during execution of the try block can be caught and
handled in a catch block. On exit from a catch block, normal execution continues and the
finally block is executed (Though the catch block throws an exception).

3. finally Block: A finally block is always executed, regardless of the cause of exit from
the try block, or whether any catch block was executed. Generally finally block is used
for freeing resources, cleaning up, closing connections etc.

Example:

The following is an array is declared with 2 elements. Then the code tries to access the

3rd element of the array which throws an exception.

// File Name : ExcepTest.java

import java.io.*;
public class ExcepTest
{
public static void main(String args[])
{
try
{
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}

Dept. of CSE, BGMIT OOC (Module 3) 30

 18CS45

This would produce following result:

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3

Out of the block

Multiple catch Blocks:

A try block can be followed by multiple catch blocks. The syntax for multiple catch blocks
looks like the following:

try
{
// code
}
catch(ExceptionType1 e1)
{
//Catch block
}
catch(ExceptionType2 e2)
{
//Catch block
}
catch(ExceptionType3 e3)
{
//Catch block
}

The previous statements demonstrate three catch blocks, but you can have any
number of them after a single try.

Dept. of CSE, BGMIT OOC (Module 3) 31

 18CS45

Example: Here is code segment showing how to use multiple try/catch

statements.

class Multi_Catch
{
public static void main (String args [])
{

try
{
int a=args.length;
System.out.println(“a=”+a);
int b=50/a;
int c[]={1}
}
catch (ArithmeticException e)
{
System.out.println ("Division by zero");
}

catch (ArrayIndexOutOfBoundsException e)
{
System.out.println (" array index out of bound");
}
}
}

OUTPUT
Division by zero
array index out of bound

Nested try Statements

 Just like the multiple catch blocks, we can also have multiple try blocks. These try
blocks may be written independently or we can nest the try blocks within each
other, i.e., keep one try-catch block within another try-block. The program
structure for nested try statement is:

Dept. of CSE, BGMIT OOC (Module 3) 32

 18CS45

Syntax

try
{
// statements
// statements

try
{
// statements
// statements
}
catch (<exception_two> obj)
{
// statements
}

// statements
// statements
}
catch (<exception_two> obj)
{
// statements
}

 Consider the following example in which you are accepting two numbers from the
command line. After that, the command line arguments, which are in the string
format, are converted to integers.

 If the numbers were not received properly in a number format, then during the
conversion a NumberFormatException is raised otherwise the control goes to the
next try block. Inside this second try-catch block the first number is divided by the
second number, and during the calculation if there is any arithmetic error, it is
caught by the inner catch block.

Dept. of CSE, BGMIT OOC (Module 3) 33

 18CS45

Example

class Nested_Try
{
public static void main (String args [ ] )
{
try
{
int a = Integer.parseInt (args [0]);
int b = Integer.parseInt (args [1]);
int quot = 0;

try
{
quot = a / b;
System.out.println(quot);
}
catch (ArithmeticException e)
{
System.out.println("divide by zero");
}
}
catch (NumberFormatException e)
{
System.out.println ("Incorrect argument type");
}
}
}

The output of the program is: If the arguments are entered properly in the command
prompt like:

OUTPUT
java Nested_Try 2 4 6
4

If the argument contains a string than the number:

Dept. of CSE, BGMIT OOC (Module 3) 34

 18CS45

OUTPUT
java Nested_Try 2 4 aa
Incorrect argument type

If the second argument is entered zero:

OUTPUT
java Nested_Try 2 4 0
divide by zero

throw Keyword

 throw keyword is used to throw an exception explicitly. Only object of

Throwable class or its sub classes can be thrown.
 Program execution stops on encountering throw statement, and the closest catch
statement is checked for matching type of exception.

Syntax : throw ThrowableInstance

Creating Instance of Throwable class

There are two possible ways to get an instance of class Throwable,

1. Using a parameter in catch block.

2. Creating instance with new operator.

new NullPointerException("test");

This constructs an instance of NullPointerException with name test.

Example demonstrating throw Keyword

Dept. of CSE, BGMIT OOC (Module 3) 35

 18CS45

class Test
{
static void avg()
{
try
{
throw new ArithmeticException("demo");
}
catch(ArithmeticException e)
{
System.out.println("Exception caught");
}
}
public static void main(String args[])
{
avg();
}
}
In the above example the avg() method throw an instance of ArithmeticException, which is
successfully handled using the catch statement.

throws Keyword

 Any method capable of causing exceptions must list all the exceptions possible
during its execution, so that anyone calling that method gets a prior knowledge
about which exceptions to handle. A method can do so by using the throws
keyword.

Syntax :

type method_name(parameter_list) throws exception_list

{
//definition of method
}

Dept. of CSE, BGMIT OOC (Module 3) 36

 18CS45

NOTE : It is necessary for all exceptions, except the exceptions of type Error and
RuntimeException, or any of their subclass.
Example demonstrating throws Keyword

class Test
{
static void check() throws ArithmeticException
{
System.out.println("Inside check function");
throw new ArithmeticException("demo");
}

public static void main(String args[])

{
try
{
check();
}
catch(ArithmeticException e)
{
System.out.println("caught" + e);
}
}
}

finally
 The finally clause is written with the try-catch statement. It is guaranteed to be
executed after a catch block or before the method quits.

Syntax

try
{
// statements
}

Dept. of CSE, BGMIT OOC (Module 3) 37

 18CS45

catch (<exception> obj)

{
// statements
}
finally
{
//statements
}

 Take a look at the following example which has a catch and a finally block. The
catch block catches the ArithmeticException which occurs for arithmetic error
like divide-by-zero. After executing the catch block the finally is also executed
and you get the output for both the blocks.

Example:

class Finally_Block
{
static void division ( )
{
try
{
int num = 34, den = 0;
int quot = num / den;
}
catch(ArithmeticException e)
{
System.out.println ("Divide by zero");
}
finally
{
System.out.println ("In the finally block");
}
}
class Mypgm
{
public static void main(String args[])
{

Dept. of CSE, BGMIT OOC (Module 3) 38

 18CS45

Finally_Block f=new Finally_Block();

f.division ( );
}
}

OUTPUT
Divide by zero
In the finally block

Java’s Built in Exceptions

Java defines several exception classes inside the standard package java.lang.

 The most general of these exceptions are subclasses of the standard type
RuntimeException. Since java.lang is implicitly imported into all Java
programs, most exceptions derived from RuntimeException are automatically
available.

Java defines several other types of exceptions that relate to its various class libraries.
Following is the list of Java Unchecked RuntimeException.

Exception Description
ArithmeticException Arithmetic error, such as divide-by-zero.
ArrayIndexOutOfBoundsException Array index is out-of-bounds.
Assignment to an array element of an
ArrayStoreException
incompatible type.

ClassCastException Invalid cast.

IllegalArgumentException Illegal argument used to invoke a method.
Illegal monitor operation, such as waiting on an
IllegalMonitorStateException
unlocked thread.

Dept. of CSE, BGMIT OOC (Module 3) 39

 18CS45

Environment or application is in incorrect

IllegalStateException
state.

Requested operation not compatible with

IllegalThreadStateException
current thread state.

IndexOutOfBoundsException Some type of index is out-of-bounds.

NegativeArraySizeException Array created with a negative size.
NullPointerException Invalid use of a null reference.
Invalid conversion of a string to a numeric
NumberFormatException format.

SecurityException Attempt to violate security.

Attempt to index outside the bounds of a
StringIndexOutOfBounds string.

UnsupportedOperationException An unsupported operation was encountered.

Following is the list of Java Checked Exceptions Defined in java.lang.

Exception Description
ClassNotFoundException Class not found.
Attempt to clone an object that does not implement the
CloneNotSupportedException
Cloneable interface.

IllegalAccessException Access to a class is denied.

Attempt to create an object of an abstract class or
InstantiationException
interface.

InterruptedException One thread has been interrupted by another thread.

NoSuchFieldException A requested field does not exist.
NoSuchMethodException A requested method does not exist.

Dept. of CSE, BGMIT OOC (Module 3) 40

 18CS45

Creating your own Exception Subclasses

 Here you can also define your own exception classes by extending Exception.
These exception can represents specific runtime condition of course you will have
to throw them yourself, but once thrown they will behave just like ordinary
exceptions.
 When you define your own exception classes, choose the ancestor carefully. Most
custom exception will be part of the official design and thus checked, meaning
that they extend Exception but not RuntimeException.

Example: Throwing User defined Exception

public class MyException extends Exception

{
String msg = "";
int marks=50;
public MyException()
{
}
public MyException(String str)
{
super(str);
}
public String toString()
{
if(marks <= 40)
msg = "You have failed";
if(marks > 40)
msg = "You have Passed";

return msg;

}
}

Dept. of CSE, BGMIT OOC (Module 3) 41

 18CS45

class test
{
public static void main(String args[])
{
test t = new test();
t.dd();
}
public void add()
{
try
{
int i=0;
if( i<40)
throw new MyException();
}
catch(MyException ee1)
{
System.out.println("Result:"+ee1);
}
}
}
OUTPUT
Result: You have Passed

Chained Exception
 Chained exceptions are the exceptions which occur one after another i.e. most of
the time to response to an exception are given by an application by throwing
another exception.
 Whenever in a program the first exception causes an another exception, that is
termed as Chained Exception. Java provides new functionality for chaining
exceptions.
 Exception chaining (also known as "nesting exception") is a technique for
handling the exception, which occur one after another i.e. most of the time

Dept. of CSE, BGMIT OOC (Module 3) 42

 18CS45

is given by an application to response to an exception by throwing another

exception.
 Typically the second exception is caused by the first exception. Therefore chained
exceptions help the programmer to know when one exception causes another.

The constructors that support chained exceptions in Throwable class are:

Throwable initCause(Throwable)
Throwable(Throwable)
Throwable(String, Throwable)
Throwable getCause()

Dept. of CSE, BGMIT OOC (Module 3) 43