 Let's consider this code that creates a circle object with a radius property. We'd like to pass it to a method that will resize it by a given factor. Here's the code for that resize method. When we pass myCircle to the method, the reference to myCircle is copied into parameter C. Because both C and myCircle refer to the same object, when we update the radius of C and exit the resize method, myCircle will have its property updated. Just as we were able to update arrays in place, when you pass an object to a method, you can update its properties in place. And again, as with arrays, there's a school of thought that says you should not change the object in place, but instead always return a new value. That would mean returning a new object in our case. Here's the rewrite of our resize code to be a method that returns a circle object. As before, we create a circle in main, and as before parameter C is a copy of the reference to myCircle. But this time, we create a new circle object with the updated radius and return that new object. A reference to that returned object is stored in newCircle, leaving the original myCircle untouched. So, which should you do? Update objects in place? Or return new objects? If you're in an environment where memory isn't a premium and you don't need the object's original state, then you may want to update it in place. In other words, my personal preference and strong preference is to return a new object. That way, you can call the function multiple times with the same input and not worry about whether the first call changed your object's properties in some unexpected way.