Behavior of return statement in catch and finally

Question

public class J {

     public Integer method(Integer x) 
        {
            Integer val = x;
            try 
            {

                    return val;
            } 
            finally 
            {
                     val = x + x;
            }
        }
        public static void main(String[] args) 
        {
            J littleFuzzy = new J();
            System.out.println(littleFuzzy.method(new Integer(10)));
        }

}

It will return "10".

Now I just replace Return type Integer to StringBuilder and Output was changed.

public class I {

     public StringBuilder method(StringBuilder x) 
        {
            StringBuilder val = x;
            try 
            {

                    return val;
            } 
            finally 
            {
                     val = x.append("aaa");
            }
        }
        public static void main(String[] args) 
        {
            I littleFuzzy = new I();
            System.out.println(littleFuzzy.method(new StringBuilder("abc")));
        }


}

OutPut is "abcaaa"

So, Anybody can explain me in detail.? what are the differences.?

I am also confused when I executed this program on my machine. In first case it return 10 (I was expecting it will return 20), in second case it is returning abcaaa (that is after appending). I am also puzzled at this behavior. (in between I am not the one who upvoted it. yet) — JProgrammer, Feb 28 '12 at 05:58
Its a good question. Got back some memories of basic's. Whats wrong with that ? — Siddharth, Feb 28 '12 at 06:00

Nirmal- thInk beYond · Accepted Answer · 2012-02-28T06:02:31.280

4

Just because integer in immutable so after method returns even if value is changed in method it does not reflect, and does reflect in StringBuilder Object

EDIT:

public class J {
    public String method(String x) {
        String val = x;
        try {
            return val;
        } finally {
            val = x + x;
        }
    }

    public static void main(String[] args) {
        J littleFuzzy = new J();
        System.out.println(littleFuzzy.method("abc"));
    }
}

edited Feb 28 '12 at 06:02

answered Feb 28 '12 at 05:53

Nirmal- thInk beYond

11,847
8
35
46

no, String is same case as integer because of it is immutable, see my edit example and execute it – Nirmal- thInk beYond Feb 28 '12 at 06:03
if you put `return val;` outside `finally` then value is changed even for `Integer` – Shahzeb Feb 28 '12 at 06:07
@Nirmal-thInkbeYond, are you sure this is the case? I think here the return value is always same as the parameter passed i.e. `x`. And in case of the `StringBuilder` method since the value of x is changed by calling `append()` method, it gets reflected in the returned value. Try changing `val = x.append("aaa");` with `val = new StringBuilder("aaa");` in case of `StringBuilder method(StringBuilder x)`. – Kuldeep Jain Feb 28 '12 at 06:17
@KuldeepJain - if you take `val = new StringBuilder("aaa");` then object returned will be different that you passed and in finally block append in object that you passed so both are completely different object that is why it happens – Nirmal- thInk beYond Feb 28 '12 at 06:23

score 0 · Answer 2 · answered Feb 28 '12 at 05:53

The principal operations on a StringBuilder are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string builder. The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.

For example, if z refers to a string builder object whose current contents are "start", then the method call z.append("le") would cause the string builder to contain "startle", whereas z.insert(4, "le") would alter the string builder to contain "starlet".

In general, if sb refers to an instance of a StringBuilder, then sb.append(x) has the same effect as sb.insert(sb.length(), x). Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.

Instances of StringBuilder are not safe for use by multiple threads. If such synchronization is required then it is recommended that StringBuffer be used.

In above method, finally block is calling everytime.

score 0 · Answer 3 · answered Feb 28 '12 at 06:38

0

When an object is passed, the copy of its reference gets passed and you can change the contents if it is mutable.

answered Feb 28 '12 at 06:38

Atul

2,673
2
28
34

Behavior of return statement in catch and finally

3 Answers3