Java code quality in methods calling methods

Question

I am currently working with an "interesting" code-base and see the following type of thing alot in the code.

public Object doSomething()
{
    Object obj = new Object();

    // Do some stuff to the object

    obj = doSomthingElse(obj);    

    return obj;
}

I always feel when looking at this kind of code that it is somewhat incorrect to have an object be passed into a method as a parameter but also set the object returned by the method to the same variable that was referencing the passed object. I would usually do something like the following, where I create a new variable to avoid any confusion.

public Object doSomething()
{
    Object obj = new Object();

    // Do some stuff to the object

    Object anotherObj = doSomthingElse(obj);     

    return anotherObj;
}

Am I wrong in thinking the second code snippet is more readable/correct?

Answer 1

If the method call is transforming the object without creating a copy of it (and then returning the same object, with the changes), the statement obj = doSomthingElse(obj); has no effect (you could just perform doSomthingElse(obj); instead).

If the method creates and returns another object (that is a modified copy of the original), then what the statement obj = doSomthingElse(obj); does is called variable reuse. To say that it is a good or a bad practice would be nothing more than an opinion.

Sticking to your abstract example, my opinion would be that you need to add some comments to the code explaining what the obj variable represents. Then, reusing it or not, you should try to stick to what is documented (the variable's role in the code).

If the result of doSomthingElse(obj) is another object and represents something different from the documented role of the variable obj, then you should use another variable (as you did), IMHO.

Answer 2

There's no right or wrong answer to this. It's very subjective. I would say that the style you are leaning towards is widely considered valid but maybe a little picky to some.

If you don't want to reuse variables, I would strongly recommend declaring them final. This will make your intention clear to the compiler as well as other devs.

I would avoid declaring a variable simply to return it but that's probably just there to illustrate your scenario.

Answer 3

Variable reuse isn't horribly wrong, but you miss a chance at writing clearer code by giving variables good names. For example, if you were manipulating a Point, use

Point origin = new Point();
Point translated = doSomething(origin);
return translated;