Java Practice : returning same object which was passed as parameter

Question

In the following code, is it really bad practice for updateWithContex to return the same object it took as a parameter?

class SomeClass{
   Foo updateWithContex(Foo foo){
       foo.setAppId(i);
       foo.setXId(index);
       //.....
       return foo;
   }
}

class Foo{

    public void setAppId(int appId)
    {
       //
    }
    public void setXId(int appId)
    {
        //
    }
    public void changeState(X x)
    {
       //
    }
}

In C++ , I have seen code like this:

 BigObject&
   fastTransform( BigObject& myBO )
   {
      // When entering fastTransform(), myBO is the same object as the function
      // argument provided by the user. -> No copy-constructor is executed.
      // Transform myBO in some way
      return myBO;   // Transformed myBO is returned to the user.
   }

Is this also wrong?

Answer 1

Returning an object will suggest to users of your API that the passed in object will not be changed and a new modified object returned instead. To make it clear that this is not the case I would suggest changing the return type to void.

Answer 2

Your code should look like this:

class SomeClass{
   void updateWithContex(Foo foo){
       foo.setAppId(i);
       foo.setXId(index);
       //.....
   }
}

It is bad practice, because you pass the reference to the foo object, so you can change it in updateWithContex method without returning it back the method. Once more, remember that you work always with reference with Java. And fore sure, there is no way how to do it elsewhere - it is going to be always a reference to an object. Java has nothing like this: fastTransform( BigObject& myBO ).