In Java, How do I return a String or a double depending on the circumstance of the method? Is it possible?

Question

For example, I have a method that looks through a string for data separated by a specified deliminator, but some items might be a names, and other items might be numbers.

If a user calls my method to return item number X from the deliminated list, i want it to return a string if item X is a name, or a double if item X is a number.

For example, objectName.get(5); would get the 5th item in the deliminated list.

Would I have to use some type of overloading for this?

Or would I have to instead do something like objectName.getDouble(5); and objectName.getString(5); based on the fact that the user knows what item 5 is?

But what if the user doesn't know what item 5 is? He just needs a String or a Double depending on what it happens to be.

Answer 1

Here's one way to do this:

public Object get() {
    if (blueMoon) {
        return new Double(42.0);
    } else {
        return "fred";
    }
}

Note that this will return a Double wrapper rather than a double.

I don't think this is a good idea though, since the caller now has to test the type of the returned value and do a typecast to do something with it.

For the record, Java does not allow a method to return a String or double because these types do not have a common supertype in the Java type system.

Answer 2

The Java language does not expose an overload on the return type of a method. (As Thilo pointed out, this is a restriction of the Java language and not the JVM/bytecode.)

Generally this type of thing does not fit well into the Java type system. One could imagine returning an Either<String,Double> type (a more restricted return type than Object as suggested by Stephen C and a more general type than DoubleOrString as pointed out by B. Bear), but the general effort required to use such a construct in Java generally results in simply having multiple methods, e.g. getString(...) and getDouble(...).

Answer 3

For this sort of thing, I prefer to use something akin to the Maybe/Option pattern from the functional programming camp. You end up with an interface like:

public abstract class DoubleOrString 
{
    // Constraint isDouble() xor isString()
    public boolean isDouble();
    public boolean isString();

    //Must throw iff !isString()
    public String getString();

    //Must throw iff !ifDouble()
    public Double getDouble();

    public static DoubleOrString wrap(final double wrapMe)
    {
       return new DoubleOrString()
       {
             public boolean isDouble() {return true;}
             public boolean isString() {return false;}
             public Double getDouble() {return wrapMe;}
             public String getString() {throw new RuntimeException();}
       };
    }

    //same for wrap(String)
}

This forces the issue for clients, in that there is always a sanity check that there was indeed a double or String at the appropriate time. In your case, I'd make just one get() method, so when the client (thinks they) knows what the type is, the call is

objectName.get(5).getString();

and in your get(int) method, rather than returning a String or a double, the return statement looks like

DoubleOrString.wrap(theThingToReturn)

It's a little extra work up front, but it has paid of for me several times in the past.

Answer 4

If you need to do this then there is problem with your design. Since the original datasource is String you have to accept that all returned values will be string and leave it to the client to check whether the result can be converted to a number.

If you want to save the client from doing the check, you can provide him with a minimal API which may look something like:

public class ValueExtractor {

    public ValueExtractor(String delimitedText) {
        // ...
    }

    /**
     * Determines whether there is a next element
     * to be returned
     */
    public boolean next() {
        // ...
    }

    public String get() {
        // ...
    }

    /**
     * Returns the value as a Double if possible
     * null otherwise.
     */
    public Double getPossibleDouble() {
        // ...
    }
}