but couldn't you just return an array of pointers to the multiple data values you want to return?

"but couldn't you just return an array of pointers to the multiple data values you want to return?

You can compile the source into a jar, or make it part of your project directly.

With C++ you'd just pass multiple values by reference, rather than muck about trying to "return" multiple values.

Java doesn't have pointers.

My first thought in C++ would be to have a templated ReturnTriple struct along the lines of:

template
struct ReturnTriple
{
A first;
B second;
C third;
};

which is cheap, type-safe and reusable.

EDIT: Or, as another poster pointed out, just pass parameters by reference. Is this not possible in Java?

Java is object-oriented! If you are afraid of creating single objects then you shouldn't use Java at all.

I think it's pretty clear from reading this article that you have very little experience in solid object oriented design. No developer worth his salt would implement a generic "two return value" wrapper like that. If you have a set of related information that gets returned, the proper way to handle it is to design a class that represents that object, and contains methods to analyze its data.

The solution you suggest is an arbitrary pairing of potentially unrelated data in a too-generic fashion, from which no meaning can be derived - and is therefor a horrible design.

"Java doesn't have pointers.

1.) Java doesn't have pointers.

2.) There's no type safety in that approach (meaning it's not a good idea for C++ too)

1. Pass the object you want manipulated, and return a boolean. Example: boolean populateObject(ObjectRef objectToPopulate)

2. Return an object reference, and test for null. Example: ObjectRef populateObject(). A null return means it failed. This is one reason I rarely use int as a return, but instead use an Integer. Then I can just test for null.

3. The best approach to do what you want (have a function return both a value and some status flag) is to use exceptions. Example: ObjectRef populateObject() throws ObjectPopulationException. Then your external code would use a try/catch to call this function. This is the norm with languages that supports exception handling.

Sorry to point this out but the fact that you nullify the class field 'h1' before returning the (reference) copy, tells me that you either do not fully understood how Java works or you need some serious OO design classes.

I don't see your problem, then again I don't know what you are trying to achieve in your program.
I never had the urge to use a multi-value return and I also came from a C++ environment, I never used it because good OO design never needed it.
Sorry to point this out but the fact that you nullify the class field 'h1' before returning the (reference) copy, tells me that you either do not fully understood how Java works or you need some serious OO design classes.

1.) Java doesn't have pointers.

People should also stop using returning implementation types rather than interfaces (in this case HashTable).

"[q]Java doesn't have pointers.

1.) Java doesn't have pointers.

If you don't see a reason why I should use a wrapper object, then why don't you see a reason for multiple return values?
It is doing the exact same thing logically.

It isn't often that I need to return multiple things. Hardly ever. I just mentioned one case where it made sense.

If I wanted to be "object oriented" using getters I could call one method compute() like so...

People should also stop using returning implementation types rather than interfaces (in this case HashTable).

It is client server. The client needs the HashTables two different ways. Nullifying it on the server and returning it to the client makes it a candidate for garbage collection on the server where I didn't want it hanging around.
All I'm saying is that there are places where multiple return values would be nice. It is basically returning a tuple but without creating meaningless wrapper classes.

Classic example is the quotient/remainder example in the integer division. To split it into two functions, you would have to do the division twice, which would be silly. Sure, you can also wrap them into an object or struct or whatever, but compare this to Python, where you just "return them" and it's completely natural.

I don't see any problems in creating an object for that.

All those who claim that it's "useless" have never tried Python.

Now tell me that ain't useful? Of course it's not something you need everyday (and it might really be bad design in many cases), but there are cases where you want to return two things that are not so closely connected to each other that they really belong into the same class.

Er, not really. const is a standard feature in C++ for declaring, well, constants.

It's hardly a hack: certainly no more than inventing silly ways to return multiple values from a function.

Imagine a language where you can only have functions with one argument. Sounds silly?

"Er, not really. const is a standard feature in C++ for declaring, well, constants.

Agree, "const-ness" defines a set of properties and behaviors over our methods and variables.

If I get a const Attribute& I'm getting a working state and I have not to worry about its memory handling.

I knew D implements it partially

All those who claim that it's "useless" have never tried Python. If Java would borrow Python's multiple return types, it would look like this:


public (String, int) findName(List names)
{
String name;
int number;

// do some searching inside the list...
// ...

// finally return the name and the amount of
// data that has been searched through (just an example)

return (name, number);
}


String name, int number = getName(someList);

System.out.println("Found: " + name);
System.out.println("I had to search through " + number + " items");


Now tell me that ain't useful? Of course it's not something you need everyday (and it might really be bad design in many cases), but there are cases where you want to return two things that are not so closely connected to each other that they really belong into the same class.

I have used it in Python before and it's very useful. I wish Java had this.

String name, int number = getName(someList);