Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Java exception

823 views

Published on

Exception: Definition, Dealing with Errors, The Classification of Exceptions, Declaring Checked
Exceptions, Throw an Exception, Creating Exception Classes, Catching Exceptions, Catching
Multiple Exceptions, Re-throwing and Chaining Exceptions, finally clause, Advantages of
Exceptions,

Published in: Education
  • Be the first to comment

Java exception

  1. 1. JAVA Exception Handling Prepared by Miss. Arati A. Gadgil
  2. 2. 2 Errors and Error Handling An Error is any unexpected result obtained from a program during execution. Unhandled errors may manifest themselves as incorrect results or behavior, or as abnormal program termination.Errors should be handled by the programmer. Traditional Error Handling 1.Every method returns a value (flag) indicating either success, failure, or some error condition. The calling method checks the return flag and takes appropriate action. Downside: programmer must remember to always check the return value and take appropriate action. This requires much code (methods are harder to read) and something may get overlooked.
  3. 3. 3 Traditional Error Handling 2. Create a global error handling routine, and use some form of “jump” instruction to call this routine when an error occurs. Downside: “jump” instruction (GoTo) are considered “bad programming practice” and are discouraged. Once you jump to the error routine, you cannot return to the point of origin and so must (probably) exit the program. Exceptions act similar to method return flags in that any method may raise and exception should it encounter an error. Exceptions act like global error methods in that the exception mechanism is built into Java; exceptions are handled at many levels in a program, locally and/or globally.
  4. 4. Exception Due to design errors or coding errors, our programs may fail in unexpected ways during execution. It is our responsibility to produce quality code that does not fail unexpectedly. Consequently, we must design error handling into our programs. An exception is a special type of error object that is created when something goes wrong in a program. After Java creates the exception object, it sends it to program, this action called throwing an exception. It's up to our program to catch the exception.
  5. 5. 5 An exception is a representation of an error condition or a situation that is not the expected result of a method. Exceptions are built into the Java language and are available to all program code. Exceptions isolate the code that deals with the error condition from regular program logic. When an error is detected, an exception is thrown Any exception which is thrown, must be caught by and exception handler If the programmer hasn't provided one, the exception will be caught by a catch-all exception handler provided by the system.
  6. 6. 6 The default exception handler may terminate the application. Exceptions can be rethrown if the exception cannot be handled by the block which caught the exception Java has 5 keywords for exception handling: 1.try 2.catch 3.finally 4.throw 5.Throws
  7. 7. 7 Exception -Class Hierarchy Throwable + Throwable(String message) + getMessage(): String + printStackTrace():void Error Exception Errors: An error represents a condition serious enough that most reasonable applications should not try to catch. - Virtual Machine Error - out of memory - stack overflow - Thread Death - Linkage Error Exceptions: An error which reasonable applications should catch - Array index out of bounds - Arithmetic errors (divide by zero) - Null Pointer Exception - I/O Exceptions See the Java API Specification for more.
  8. 8. 8 Exceptions -Checked and Unchecked Java allows for two types of exceptions: 1.Checked. If your code invokes a method which is defined to throw checked exception, your code MUST provide a catch handler The compiler generates an error if the appropriate catch handler is not Present 2.Unchecked These exceptions can occur through normal operation of the virtual machine. You can choose to catch them or not. If an unchecked exception is not caught, it will go to the default catch-all handler for the application All Unchecked exceptions are subclassed from RuntimeException
  9. 9. 9 Common Java Exceptions. ArithmeticException :Caused by math errors such as division by zero ArrayIndexOutOfBoundsException:Caused by bad array indexes ArrayStoreException: Caused when a program tries to store the wrong type of data in an array FileNotFoundException: Caused by an attempt to access a nonexistent file IOException: Caused by general I/O failures, such as inability to read from a file NullPointerException: Caused by referencing a null object NumberFormatException: Caused when a conversion between strings and numbers fails
  10. 10. 10 OutOfMemoryException: Caused when there's not enough memory to allocate a new object SecurityException: Caused when an applet tries to perform an action not allowed by the browser'ssecurity setting StackOverflowException: Caused when the system runs out of stack space StringIndexOutOfBoundsException:Caused when a program attempts to access a nonexistent characterposition in a string
  11. 11. 11 Exceptions –Syntax try { // Code which might throw an exception // ... } catch(FileNotFoundException x) { // code to handle a FileNotFound exception } catch(IOException x) { // code to handle any other I/O exceptions } catch(Exception x) { // Code to catch any other type of exception } finally { // This code is ALWAYS executed whether an exception was thrown // or not. A good place to put clean-up code. ie. close // any open files, etc... }
  12. 12. 12 Try-Catch Mechanism Wherever your code may trigger an exception, the normal code logic is placed inside a block of code starting with the “try” keyword: After the try block, the code to handle the exception should it arise is placed in a block of code starting with the “catch” keyword. You may also write an optional “finally” block. This block contains code that is ALWAYS executed, either after the “try” block code, or after the “catch” block code. Finally blocks can be used for operations that must happen no matter what (i.e. cleanup operations such as closing a file)
  13. 13. 13 throws keyword The throws keyword is used in method declaration, in order to explicitly specify the exceptions that a particular method might throw. When a method declaration has one or more exceptions defined using throws clause then the method-call must handle all the defined exceptions. When defining a method you must include a throws clause to declare those exceptions that might be thrown but doesn’t get caught in the method. If a method is using throws clause along with few exceptions then this implicitly tells other methods that – “ If you call me, you must handle these exceptions that I throw”. Syntax of Throws in java: void MethodName() throws ExceptionName{ Statement1 ... ... }
  14. 14. 14 throw Keyword By default, when an exception condition occurs the system automatically throw an exception to inform user that there is something wrong. However we can also throw exception explicitly based on our own defined condition. Using “throw keyword” we can throw checked, unchecked and user -defined exceptions.
  15. 15. 15 public class ThrowExample { static void checkEligibilty(int stuage, int stuweight) { if(stuage<12 && stuweight<40) { throw new ArithmeticException("Student is not eligible for registration"); } else { System.out.println("Entries Valid!!"); } } public static void main(String args[]) { System.out.println("Welcome to the Registration process!!"); checkEligibilty(10, 39); System.out.println("Have a nice day.."); } }
  16. 16. 16 import java.io.*; class Example { public static void main(String args[]) throws IOException { FileInputStream fis = null; fis = new FileInputStream("B:/myfile.txt"); int k; while(( k = fis.read() ) != -1) { System.out.print((char)k); } fis.close(); } } Declare the exception in the method using throws keyword.
  17. 17. 17 import java.io.*; class Example { public static void main(String args[]) { FileInputStream fis = null; try{ fis = new FileInputStream("B:/myfile.txt"); }catch(FileNotFoundException fnfe) { System.out.println("The specified file is not exist); } int k; try{ while(( k = fis.read() ) != -1) { System.out.print((char)k); } fis.close(); }catch(IOException ioe) { System.out.println("I/O error occurred: "+ioe); } }
  18. 18. 18 Throw vs Throws in java 1. Throws clause in used to declare an exception and thow keyword is used to throw an exception explicitly. 2. If we see syntax wise than throw is followed by an instance variable and throws is followed by exception class names. 3. The keyword throw is used inside method body to invoke an exception and throws clause is used in method declaration (signature). 4.By using Throw keyword in java you cannot throw more than one exception but using throws you can declare multiple exceptions. PFB the examples.
  19. 19. 19 User defined exception User defined exceptions in java are also known as Custom exceptions. Most of the times when we are developing an application in java, we often feel a need to create and throw our own exceptions. These exceptions are known as User defined or Custom exceptions. class MyException extends Exception { String str1; MyException(String str2) { str1=str2; } public String toString() { return ("Output String = "+str1) ; } }
  20. 20. 20 class CustomException { public static void main(String args[]) { try { throw new MyException("Custom"); // I'm throwing user defined custom exception above } catch(MyException exp) { System.out.println("Hi this is my catch block") ; System.out.println(exp) ; } } }
  21. 21. 21 Defining Your Own Exceptions To define your own exception you must do the following: Create an exception class to hold the exception data.Your exception class must subclass "Exception" or another exception class To create unchecked exceptions, subclass the RuntimeException class. Minimally, your exception class should provide a constructor which takes the exception description as its argument. To throw your own exceptions: If your exception is checked, any method which is going to throw the exception must define it using the throws keyword When an exceptional condition occurs, create a new instance of the exception and throw it.
  22. 22. 22 Rethrowing Exceptions  M2() throws an exception and M1() handles it and then rethrows it. class MyException extends Exception { } public class RethrowException  {    public static void main(String[] args)  {   try         { M1(); }            catch (Exception e)      { System.out.println("main(): Caught " + e.toString()); }   }    public static void M1() throws MyException  {   try         { M2(); } 
  23. 23. 23 catch (Exception e)      {   System.out.println("M1(): Caught e.toString());                            System.out.println("M1(): Rethrowing " + e.toString());                      throw e;                  }               }    public static void M2() throws MyException  {  System.out.println("M2(): Throwing MyException...");  throw new MyException();  }  } 
  24. 24. 24 Advantages of Exceptions 1: Separating Error-Handling Code from "Regular" Code 2: Propagating Errors Up the Call Stack 3: Grouping and Differentiating Error Types
  25. 25. Thank You 25

×