Improved Exception handling in Java 7

Java 7 has improved the exception handling by ease of development, reduced code duplication  and intelligent throws clause.

1. More than one  exception types in single catch block: Java 7 onwards single catch block can handle multiple exception types. Now Catch block can specify ‘|’ separated exception types instead of only one exception. It prevent code duplication in case when same operation has to perform for all of set of types of exceptions and improve code readability.

Old style :

try{
    //your code here
}catch (IOException ex) {
     log(ex);
     throw ex;
catch (SQLException ex) {
     log(ex);
     throw ex;
}


New style:


try{
    //your code here
}catch (IOException|SQLException ex) {
     logger.log(ex);
     throw ex;
}


2. Intelligent throws clause : Method declaration has to include the list of exception its is going to throws using throws clause. These exception types has to be matched with catch block throw statement. Java 7 onwards compiler is more intelligent to analysis the code and allows to declares exception types in method throws declaration  based on following condition.



  • The try block is able to throw it.

  • There are no other preceding catch blocks that can handle it.

  • It is a subtype or supertype of one of the catch clause's exception parameters.

For example, consider code below



public void test1()throws Exception {
        try{
            File f = new File("sample");
            f.getAbsolutePath();// throws SecurityException exception
        }catch (Exception exp){//catching super type
            throw exp;//throwing Exception
        }
    }


In above code f.getAbsolutePath()throws SecurityException but catch block parameter is Exception ( Super type). As catch block is throwing exception of type Exception, throws clause in method declaration has mention Exception.


In Java7, same code you can write like below



 
public void test1()throws SecurityException {
        try{
            File f = new File("sample");
            f.getAbsolutePath();// throws SecurityException exception
        }catch (Exception exp){//catching super type
            throw exp;//throwing Exception
        }
}


Here test1 method declares SecurityException instead of Exception. Java 7 compiler allows you specify exception type SecurityException in throws  clause of method test1 because you can throw a exception that is super type of any of the type declared in the throws .


Here compiler knows exception of type SecurityException is being throw from try block.


Reference :


http://download.oracle.com/javase/7/docs/technotes/guides/language/catch-multiple.html

Comments

  1. Neil GhoshAugust 2, 2011 at 6:34 AM

    Thanks for the tips

    ReplyDelete
  2. Alosh BennettAugust 3, 2011 at 9:04 PM

    The second one is really interesting!

    ReplyDelete
  3. ArunSeptember 1, 2011 at 5:11 AM

    Yogesh I didn't understand the second one.
    What if if f.getAbsolutePath() throws IOException. Your catch block would catch it and throw it right?
    But your throws class doesn't have IOException it.
    Am I missing something?

    ReplyDelete

Post a Comment

Popular posts from this blog

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior...
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm...
Read more

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); ...
Read more