Exception
=======
Java exception handling is
managed via five keywords.
try
catch
throw
throws
finally
The general form of an
exception-handling block:
try
{
//block of code to monitor for errors
}
catch(Exception Type1 exObj)
{
//exception handler for ExceptionType1
}
catch(Exception Type2 exOb)
{
//exception handler for Exception Type2
}
//......
finally
{
//block of code to be executed before try block ends
}
Here, Exception Type is the
type of exception that has occurred.
All exception types are subclasses
of the built-in class Throwable.
Program1
-------------
class Ex
{ public static void main(String args[])
{
int d=0;
int a=42/d;
System.out.println("a="+a);
}
}
Program2
-------------
class Exc1{
static void subroutine(){
int d=0;
int a=10/d;
}
public static void main(String args[]){
Exc1.subroutine();
}
}
Program3
-------------
class Exc2{
public static void main(String args[]){
int d,a;
try{
d=0;
a=42/d;
System.out.println("This is will
not be printed");
}
catch(ArithmeticException
e)
{
System.out.println("Division by
zero");
}
System.out.println("After catch
statement");
}
}
Demonstrate multiple catch statements.
--------------------------------------------------
class MultiCatch
{
public static void main(String args[]){
try{
int a=args.length;
System.out.println("a="+a);
int b=42/a;
int c[]={1};
c[42]=99;
}catch(ArithmeticException e){
System.out.println("Divide by
0:"+e);
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Array
index oob:"+e);
}
System.out.println("After try/catch
blocks.");
}
}
//This program contains an
error.
class SuperSubCatch{
public static void main(String args[]){
try{
int a=0;
int b=42/a;
}catch(Exception e)
{
System.out.println("Generic
Exception catch.");
}
/*This catch is never reached because Arithmetic
Exception is a subclass of Exception*/
/* catch(ArithmeticException
e){
System.out.println("This is never
reached.");
}*/
}
}
An example of nested try statement.
class NestTry{
public static void main(String args[])
{
try{
int a=args.length;
int b=42/a;
System.out.println("a="+a);
try{
if(a==1)
a=a/(a-a);
if(a==2)
{
int c[]={1};
c[42]=99;
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Array
Index Out of Bounds:"+e);
}
}
catch(ArithmeticException e){
System.out.println("Divide by 0:
"+e);
}
}
}
Try statements can be implicitly nested via calls to
methods.
class MathNestTry{
static void nesttry(int a){
try{
if(a==1)
a=a/(a-a);
if(a==2)
{
int c[]={1};
c[42]=99;
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Array Index Out of
Bounds:"+e);
}
}
public static void main(String args[])
{
try{
int a=args.length;
int b=42/a;
System.out.println("a="+a);
nesttry(a);
}
catch(ArithmeticException e){
System.out.println("Divide
by 0: "+e);
}
}
}
throw
--------
general form of throw is
shown here:
throw ThrowableInstance;
Here, ThrowableInstance must
be an object of type Throwable or a subclass of Throwable.
class ThrowDemo
{
static void demoproc(){
try{
throw new
NullPointerException("Demo");
}catch(NullPointerException e){
System.out.println("Caught inside
demoproc.");
throw e;
}
}
public static void main(String args[]){
try{
demoproc();
}catch(NullPointerException e){
System.out.println("Recaught
:"+e);
}
}
}
Here, new is used to
construct an instance of NullPointerException.
All of Java's built-in-run-time exceptions have two constructors: one
with no prameter and one that takes a string parameter. When the second form is used, the argument
specifies a string that describes the exception. This string is displyed when the object is
used as an argument to print() or println().
It can also be obtained by a call to getMessage(), which is defined by
Throwable.
throws
---------
The general form
type
method-name(parameter-list)throws exception-list
{
//body of method
}
class ThrowsDemo
{
static void throwone()throws IllegalAccessException
{
System.out.println("Inside throwOne.");
throw new
IllegalAccessException("demo");
}
public static void main(String arg[])
{
try{
throwone();
}catch(IllegalAccessException e){
System.out.println("Caught
"+e);
}
}
}
Finally
---------
class Final
{
public static void main(String arg[])
{
int a,d;
try
{
d=0;//d=10;
a=50/d;
System.out.println("Exception not
occur");
System.out.println(a);
}
catch(Exception ae)
{
System.out.println("Don't use zero
divisor");
}
finally{
System.out.println("U continue your
work");
}
System.out.println("After try/catch
statement");
}
}
Java's Built-in Exceptions
---------------------------------
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.
Exception Meaning
·
ArithmeticException Arithmetic error, such as
divide-
by-zero.
·
ArrayIndexOutOfBoundsException Array index is out-of-bounds.
·
ArrayStoreException Assignment to an array
element
of an incompatible type.
·
IllegalArgumentException Illegal argument used to invoke
a method
·
IndexOutOfBoundsException some type of index is out-of-
bounds.
·
NegativeArraySizeException Array created with a negative
size.
·
NullPointerException Invalid use of a null
reference.
·
NumberFormatException Invalid conversion of
a string to
a numeric format
·
SecurityException Attempt to violate security
Creating Your Own Exception Subclasses
================================
This program creates a custom
exception type.
class MyException extends
Exception{
int detail;
MyException(int a){
detail=a;
}
public String toString(){
return "MyException["+detail+"]";
}
}
class ExceptionDemo{
static void compute(int a)throws MyException{
System.out.println("Called
compute("+a+")");
if(a>10)
throw new MyException(a);
System.out.println("Normal exit");
}
public static void main(String args[])
{
try{
compute(1);
compute(22);
}catch(Exception e){
System.out.println("Caught
"+e);
}
}
}
Method Description
getMessage Returns a string containing
the error message.
toString Returns a string describing the
exception object.
StackTraceelements
Writes the exception object
and its backtrace to standard error.A stack trace is a listing of all pending
method calls at a particular point in the execution of the program.
No comments:
Post a Comment