CODEWITHSUNDEEP
javastringobjectintreturn
user3327640
user3327640

Reputation: 21

Java Return between a int or String(unknown return type)

My program loads information from a text file and creates an array of an object with the information whether it is a integer or a string.

I then want the object to return either a String or an Integer depending on whether the object is holding a integer value or a string value.

edit... So here is my type class that holds either a int if the field in the text file is a number, or a string if the field is a word, and this is held in a Type array.

public class Type {

  private String name;
  private int value;

  public Type(String name) {
      this.name = name;
  }

  public Type(int value) {
      this.value = value;
  }

  public String getName() {
      return this.name;
  }

  public int getValue() {
      return this.value;
  }

  public boolean isInt() {
      boolean isInt = false;
      if (this.value != 0) {
        isInt = true;
        return isInt;
      }
      return isInt;
  }

}

So in my array could be either a Int or a String, i want to return the datatype without any long statements in my main class.

Upvotes: 2

Views: 8618

Answers (5)

Chris K
Chris K

Reputation: 11925

When I have this type of problem, I sometimes solve it by turning the problem around and using a callback-style solution.

For example:

for ( Type t : array ) {
  t.process( callback );
}

Where the callback looks like this:

interface Callback {
  public void processInt(....);
  public void processString(....);
}

You can then either implement the process method either with an if (isInt()) callback.processInt() else callback.processString(), or if you change the definition of Type you can use the inheritance tree to do it for you.

For example:

interface Type {
  public void process( Callback cb );
}

class IntType implements Type {
  public void process( Callback cb ) {
    cb.processInt(...);
  }
}

class StringType implements Type {
  public void process( Callback cb ) {
    cb.processString(...);
  }
}

Upvotes: 1

yamilmedina
yamilmedina

Reputation: 3395

If you strictly want only to get the specific values, you could add a method to your Type class and get the values from this method, ugly but does what you want:

public <T> T getDynamicValue(Type t) {
     if (isInt()) {
          return (T) ((Integer) t.getValue());
     } else {
          return (T) t.getName();
     }
}

use of it:

List<Type> dynamicList = Arrays.asList(new Type[]{new Type(1), new Type(2), new Type("dog")});
for (Type t : dynamicList) {
    System.out.println("T -> " + t.getDynamicValue(t));
}

If you want to perform some manipulation with this data, you have to make an instanceof check and Cast it, for instance some splitting (or String methods) with the name value...

Upvotes: 3

BadSkillz
BadSkillz

Reputation: 2003

You could try to cast the object into an Integer and catch the ClassCastException:

try {
    int i = (Integer) object;
}
catch (ClassCastException e){
    String s = (String) object;
}

Upvotes: 1

jmkgreen
jmkgreen

Reputation: 1643

If you are reading all inputs into String instances, you will need to test the values against Integer.parseString(value) to find out if it is actually an Integer.

Upvotes: 1

Alessandro Roaro
Alessandro Roaro

Reputation: 4733

You can't choose the type of object to return at runtime. Your only option is to return an Object. You can check if it's a String or an int using this code, for example:

if(object instanceof String) {
   //... it's a string
}
else {
   //...otherwise it's an int
}

Upvotes: 1

Related Questions