I was reading this and wondered whether there is a particular reason for having methods which fill a pre-existing array or object with data, rather than returning an instance of the object or data.
In some cases, such as graphics it allows an object to be re-used only rewriting the primitives without allocating another object on each call.
Are there any other benefits which I am not considering?
I was reading this and wondered whether there is a particular reason for having methods which fill a pre-existing array or object with data, rather than returning an instance of the object or data.
These are two alternative ways.
Providing a object to be populated as parameter of a method has some advantages when (there are of course others):
1) you want to provide to the method an object with a state defined by the client and not in a generic or pristine state defined in the invoked method.
Without passing an instance of it as parameter, you cannot do it.
2) you want to spare memory consumption. If you have already an object to pass it as parameter, why creating a new one in the invoked method ?
3) you have multiple objects to value in the method but a method can only return a single object.
Imagine you want to populate 3 lists in the implementation.
For example you could invoke poupulateList(myList, myOtherList, myAgainOtherList);
with this implementation :
public void populateList(List<String> list, List<String> myOtherList, List<String> myAgainOtherList){
....
}
Without passed the objects as parameters you are forced to introduce a custom class that contains all these objects and to define it as the returned type of the method.
Consider the following simplistic method, which fills an integer array with a few numbers:
public void fillArray(int[] array) {
array[0] = 0;
array[1] = 1;
array[2] = 2;
}
// now use it
int[] array = new array[3];
fillArray(array);
When the method fillArray() populates the array with some values, it is addressing the actual array passed in by the caller. The caller retains the reference to his array, and hence there is no need to pass a reference back to the data. Note that we could change the signature of fillArray() to int[], and return a reference to the array, but functionally speaking it would not make much difference.
Where returning an int[] might make sense is if we wanted to make a method which allocated space for an array and then returned the result, e.g.
public int[] getArray() {
int[] array = new int[3];
array[0] = 0;
array[1] = 1;
array[2] = 2;
return array;
}
In this case, the caller doesn't have/want any exposure to workings of the array, he only wants the final product. Therefore, returning a reference to the array makes sense, without which the caller could not use the data generated by the method.
I understand why you are wondering. The design of MemoryInfo and getMemoryInfo() allow you to create as many MemoryInfo objects as you want, but if they were all to be correct, they should all hold the same data, so it would not really make sense to do. A clearer design would give you four getters that would return the four values.
I suppose that one reason for the chosen design is efficiency: it allows you to pass the same object to the method on every call, and it gives you all the information in one call instead of four. I am guessing here, though.
In general there are more things to consider when choosing one design over another. For example, if a method is to give you some information about a person, I would find it natural to pass a person object in for the method to modify rather than the method returning a new person object representing the same person every time called. Or at least it should give you the same object each time, only a new one when you inquire about a new person.
