Methods that return more than one object.

Question

Hello everyone,
I don't know if this has ever been proposed or if there's an actual solution to this in any programming language. I just think it would be very interesting and would like to see it someday.
This is the thing: why isn't it possible for a method to return more than one object. They can receive as many parameters as wanted (I don't know if there's a limit), but they can return only 1 object. So, if you need to return more than one, you have to use an auxiliary class...
public class Person {
   private String name;
   private String lastName;
   public Person(String name, String lastName) {
      this.name = name;
      this.lastName= lastName;
   public String getName() {
       return name;
   public String getLastName() {
       return lastName;
}So if you want to get the name of somebody you have to do this, assuming "person" is an instance of the object Person:
String name = person.getName();And you need a whole new method (getLastName) for getting the person's last name:
String lastName = person.getLastName();Anyway, what if we were able to have just one method that would return both. My idea is as follows:
public class Person {
   private String name;
   private String lastName;
   public Person(String name, String lastName) {
      this.name = name;
      this.lastName= lastName;
   public String name, String lastName getName() {
       return this.name as name;
       return this.lastName as lastName;
}And you would be able to do something like:
String name = person.getName().name;and for the last name you would use the same method:
String lastName = person.getName().lastName;It may not seem like a big deal in this example, but as things get more complicated simplicity becomes very useful.
Imagine for example that you were trying to get information from a database with a very complex query. If you only need to return 1 column you have no problem, since your object can be an array of Strings (or whatever type is necessary). But if you need to retrieve all columns, you have three options:
- Create 1 method per column --> Not so good idea since you're duplicating code (the query).
- Create and auxiliary object to store the information --> Maybe you won't ever use that class again. So, too much code.
- Concatenate the results and then parse them where you get them. --> Too much work.
What do you think of my idea? Very simple, very straight-forward.
I think it should be native to the language and Java seems like a great option to implement it in the future.
Please leave your comments.
Juan Carlos García Naranjo

Answer 1

It's pretty simple. In OO, a method should do one thing. If that thing is to produce an object that contains multiple values as part of its state, and that object makes sense as an entity in its own right in the problem domain--as opposed to just being a way to wrap up multiple values that the programmer finds it convenient to return together--then great, define the class as such and return an instance. But if you're returning multiple values that have nothing to do with each other outside of the fact that it's convenient to return them together, then your method is probably doing too much and should be refactored.
As for the "if it increases productivity, why not add it?" argument, there are lots of things that would "increase productivity" or have some benefit or other, but it's not worth having them in the language because the value they add is so small as to no be worth the increase in complexity, risk, etc. MI of implementation is one great example of something that a lot of people want because it's convenient, but that has real, valid utility only in very rare cases. This feature is another one--at least in the domain that Java is targetting, AFAICT.