• Like

Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Exception handling

  • 1,560 views
Uploaded on

 

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
1,560
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
79
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. 1
    Exception Handling in Java
    Shashwat Shriparv
    dwivedishashwat@gmail.com
    InfinitySoft
  • 2. 2
    Exception Handling in Java
    throw
    It is possible to throw an exception explicitly.
    Syntax:
    throwThrowableInstance
    throwableInstance must be an object of type Throwable or a subclass of Throwable.
    By 2 ways v can obtain a Throwable object
    1.Using parameter into a catch clause
    2.Creating one with new operator
  • 3. 3
    class throwDemo
    {
    public static void main(String s[])
    {
    int size;
    intarry[]=new int[3];
    size=Integer.parseInt(s[0]);
    try
    {
    if(size<=0)
    throw new NegativeArraySizeException("Illegal Array size");
    for(inti=0;i<3;i++)
    arry[i]+=i+1;
    }
    catch(NegativeArraySizeExceptione)
    {
    System.out.println(e);
    throw e; //rethrow the exception
    }
    }
    }
    new operator used
    parameter used into catch clause
  • 4. 4
    throws
    If a method causing an exception that it doesn't handle, it must specify this behavior that callers of the method can protect themselves against the exception.
    This can be done by using throws clause.
    throws clause lists the types of exception that a method might throw.
    Form
    type methodname(parameter list) throws Exception list
    {//body of method}
  • 5. 5
    import java.io.*;
    class ThrowsDemo
    {
    psvm(String d[])throws IOException,NumberFormatException
    {
    int i;
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(in);
    i=Integer.parseInt(br.readLine());
    System.output.println(i);
    }}
  • 6. 6
    finally
    • It creates a block of code that will b executed after try/catch block has completed and before the code following try/catch block.
    • 7. It will execute whether or not an exception is thrown
    finally is useful for:
    • Closing a file
    • 8. Closing a result set
    • 9. Closing the connection established with db
    This block is optional but when included is placed after the last catch block of a try
  • 10. 7
    Form:
    try
    {}
    catch(exceptiontype e)
    {}
    finally
    {}
    try block
    finally
    Catch block
    finally
  • 11. 8
  • 12. Java Exception Type Hierarchy
  • 13. Object
    Throwable
    Exception
    Error
    RunTimeException
    LinkageError
    ArithmeticException
    IndexOutOfBoundsException
    ThreadDeath
    StringIndexOutOfBoundsException
    IllegalArguementException
    VirtualMachineError
    NumberFormatException
    IllegalAccessException
    AWTError
    NoSuchMethodException
    10
    ClassNotFoundException
  • 14. 11
  • 15. 12
    Unchecked Exceptions
    The types of exceptions that need not be included in a method’s throws list are called Unchecked Exceptions.
  • 16. 13
    Unchecked Exceptions
    Exception
    Meaning
    ArithmeticException
    ArrayIndexOutOfBoundsException
    ArrayStoreException
    ClassCastException
    IllegalArgumentException
    IllegalMonitorStateException
    IllegalStateException
    IllegalThreadStateException
    IndexOutOfBoundsException
    NegativeArraySizeException
    Arithmetic error, such as divide-by-zero.
    Array index is out-of-bounds.
    Assignment to an array element of an incompatible type.
    Invalid cast.
    Illegal argument used to invoke a method.
    Illegal monitor operation, such as waiting on an unlocked thread.
    Environment or application is in incorrect state.
    Requested operation not compatible with current thread state.
    Some type of index is out-of-bounds.
    Array created with a negative size.
  • 17. 14
    Checked Exceptions
    The types of exceptions that must be included in a method’s throws list if that method can generate one of these exceptions and does not handle it ,are called Checked Exceptions.
  • 18. 15
    Checked Exceptions
    Meaning
    Exception
    Class not found.
    Attempt to clone an object that does not implement the Cloneable interface.
    Access to a class is denied.
    Attempt to create an object of an abstract class or interface.
    One thread has been interrupted by another thread.
    A requested field does not exist.
    A requested method does not exist.
    ClassNotFoundException
    CloneNotSupportedException
    IllegalAccessException
    InstantiationException InterruptedException NoSuchFieldException
    NoSuchMethodException
  • 19. A checked exception is any subclass of Exception (or Exception itself), excluding class RuntimeException and its subclasses.
    Making an exception checked forces client programmers to deal with the possibility that the exception will be thrown.
    eg, IOException thrown by java.io.FileInputStream's read() method .
    Unchecked exceptions are RuntimeExceptionand any of its subclasses. Class Error and its subclasses also are unchecked.
    16
    Java’s Built-in Exceptions: inside java.langpackage
  • 20. With an unchecked exception, however, the compiler doesn't force client programmers either to catch the exception or declare it in a throws clause.
    In fact, client programmers may not even know that the exception could be thrown.
    eg, StringIndexOutOfBoundsException thrown by String's charAt() method.
    Checked exceptions must be caught at compile time. Runtime exceptions do not need to be.
    17
  • 21. 18
    Creating our own Exception class
    For creating an exception class our own simply make our class as subclass of the super class Exception.
    Eg:
    class MyException extends Exception
    {
    MyException(String msg)
    {
    super(msg);
    }
    }
  • 22. 19
    class TestMyException
    {
    public static void main(String d[])
    {
    int x=5,y=1000;
    try
    {
    float z=(float)x/(float)y;
    if(z<0.01)
    {
    throw new MyException("too small number");
    }
    }
  • 23. 20
    catch(MyException me)
    {
    System.out.println("caught my exception");
    System.out.println(me.getMessage());
    }
    finally
    {
    System.out.println("from finally");
    }
    }
    }
    Output
    • E:JAVAPGMS>java TestMyException
    • 24. caught my exception
    • 25. too small number
    • 26. from finally
  • 21
    Summary
    Objective of Exception Handling
    Making safer program by providing special mechanism
  • 27. Thank you
    Shashwat Shriparv
    dwivedishashwat@gmail.com
    InfinitySoft
    22