Your SlideShare is downloading. ×
17   exceptions
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

17 exceptions


Published on

  • Be the first to comment

  • Be the first to like this

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. Exceptions
  • 2. Guarded section
    A block where you think some exceptional things – problem with data base connection, network failure, missing data – may happen
    try block
  • 3. The thrown exception must end up someplace – exception handler
    Exception handlers immediately follow the try block and are denoted by the keyword catch
    try {
    // Code that might generate exceptions
    } catch(Type1 id1)|{
    // Handle exceptions of Type1
    } catch(Type2 id2) {
    // Handle exceptions of Type2
    } catch(Type3 id3) {
    // Handle exceptions of Type3
    Exception Handler
  • 4. If an exception is thrown, the exception-handling mechanism goes hunting for the first handler with an argument that matches the type of the exception
    Then it enters that catch clause, and the exception is considered handled
    The search for handlers stops once the catch clause is finished. Only the matching catch clause executes (unlike switch – no need for break or default)
    Sometimes one handler can be sufficient.
    Catch block
  • 5. To create your own exception class, you must inherit from an existing exception class, preferably one that is close in meaning to your new exception
    class SimpleException extends Exception {}
    Creating your own exceptions
  • 6. public class InheritingExceptions {
    public void f() throws SimpleException {
    System.out.println("Throw SimpleException from f()");
    throw new SimpleException();
    public static void main(String[] args) {
    InheritingExceptionssed = new InheritingExceptions();
    try {
    } catch(SimpleException e) {
    System.out.println("Caught it!");
    printStackTrace – shows sequence of methods called and where exactly in execution the exception was raised making it easier to pin point exception source.
    Using your own exception
  • 7. In Java, you’re encouraged to inform the client programmer, who calls your method, of the exceptions that might be thrown from your method
    This is civilized, because the caller can then know exactly what code to write to catch all potential exceptions
    Add throws followed by Exception names to tell the world the problems your code may cause
    Throwing Exceptions
  • 8. void f() throws TooBig, TooSmall, DivZero { //...
    void f() { //...
    This is not safe and can be vulnerable to RuntimeException and its likes
    Throwing Exceptions
  • 9. It is possible to create a handler that catches any type of exception by catching the base-class exception type Exception
    catch(Exception e) {
    System.out.println("Caught an exception");
    Since the Exception class is the base of all the exception classes that are important to the programmer, you don’t get much specific information about the exception, but you can call the methods that come from its base type Throwable
    String getMessage( )
    String getLocalizedMessage( )
    void printStackTrace( )
    void printStackTrace(PrintStream)
    void printStackTrace(
    Catching any Exception
  • 10. Write a Java code which first has an exception handler for Exception class followed by another exception handler for custom MyClass
  • 11. The Java class Throwable describes anything that can be thrown as an exception
    Error represents compile-time and system errors that you don’t worry about catching
    Exception is the basic type that can be thrown from any of the standard Java library class methods and from your methods and runtime accidents. So the Java programmer’s base type of interest is usually Exception.
    This are called checked exceptions
    Standard Java Exceptions
  • 12. RuntimeException and its children have special meaning to the runtime.
    They cause hazards without intimation – you do not declare them in the method exception specification
    They generally results of programming errors
    Use runtime exception if a you cannot recover from an operation
    If you are handling/catching RuntimeException there is problem in your code and design
    Unchecked Exceptions
  • 13. public class NeverCaught {
    static void f() {
    throw new RuntimeException("From f()");
    static void g() {
    public static void main(String[] args) {
    RuntimeException in Action
  • 14. There’s often some piece of code that you want to execute whether or not an exception is thrown within a try block
    To achieve this effect, you use a finally clause at the end of all the exception handlers
    try {
    // The guarded region: Dangerous activities
    // that might throw A, B, or C
    } catch(A a1) {
    // Handler for situation A
    } catch(B b1) {
    // Handler for situation B
    } catch(C c1) {
    // Handler for situation C
    } finally {
    // Activities that happen every time
    And finally
  • 15. class ThreeException extends Exception {}
    public class FinallyWorks {
    static int count = 0;
    public static void main(String[] args) {
    while(true) {
    try {
    // Post-increment is zero first time:
    if(count++ == 0)
    throw new ThreeException();
    System.out.println("No exception");
    } catch(ThreeException e) {
    } finally {
    System.out.println("In finally clause");
    if(count == 2) break; // out of "while"
    Finally in Action
  • 16. public class MultipleReturns {
    public static void f(inti) {
    print("Initialization that requires cleanup");
    try {
    print("Point 1");
    if(i== 1) return;
    print("Point 2");
    if(i== 2) return;
    print("Point 3");
    if(i== 3) return;
    }finally {
    print("Performing cleanup");
    public static void main(String[] args) {
    for(int i = 1; i <= 4; i++)
    finally and return
  • 17. Q&A