How can I use generics to provide a "universal getter method"?

user_766736 0
Viewed 82

This question is more theoretical (what I want to do is more complicated but this is the part I'm stuck on), so apologies for the contrived example which may not make much sense.

Say I have some class that has methods that return its value in different forms:

public class MyObject {
    public String getAsString() {...}
    public int getAsInt() {...}
    // and so on
}

I'm trying to create a single method to allow me to specify which MyObject method to call via its parameters. Something like:

public <T> T getValue(MyObject obj, Class<T> c) {
    if (c == String.class) {
        return obj.getAsString();
    } else if (c == Integer.class) {
        return obj.getAsInt();
    } // and so on
}

So then I would like to call this method like this, assuming obj is a MyObject:

String s = getValue(obj, String.class);
int i = getValue(obj, Integer.class);
// and so on

I'm getting the compile error "Type mismatch: cannot convert from String to T" (and likewise for Integer) in the getValue method. Clearly I'm just not understanding generics fully, but I thought this was the general idea behind generics - here I'm specifying (or trying to specify, at least) the real type of T via the parameter c. What am I doing wrong?

generics java
2 Answers

If you want to to create a single method with really safe casts - then I would suggest to setup a mapping between the expected type and its respective getter.

Given the MyObject class definition as:

public class MyObject {

    public int getIntValue() {
        return 42;
    }

    public String getStringValue() {
        return "Answer";
    }
}

So that the "accessor" class could look as follows (it can be generalized further if needed):

public class MyObjectAccessor {    
    private final Map<Class<?>, Function<MyObject, ?>> registry = new HashMap<>();
    
    public Accessor() {
        registerGetter(Integer.class, MyObject::getIntValue);
        registerGetter(String.class, MyObject::getStringValue);
    }
    
    private <T> void registerGetter(Class<T> type, Function<MyObject, T> getter) {
        registry.put(type, getter);
    }
    
    @SuppressWarnings("unchecked")
    public <T> Optional<T> getValue(MyObject obj, Class<T> type) {
        return (Optional<T>) ofNullable(registry.get(type)).map(getter -> getter.apply(obj));
    }
}

This would allow you to make the behavior much more predictable with a control over the unexpected/missing mapping. (Here it returns an Optional back, but you can also throw an exception or provide a default value or do something else)

Please note that the cast inside getValue is actually a safe checked cast (even though it was marked with @SuppressWarnings) as the "safety" proof here is a little bit beyond current javac's capability of static code analysys.

user_16896080

First of all, if getAsString and getAsInt are not doing any conversion (such as would be the case if all your values were stored as strings), you probably can reduce your method to this:

public <T> T getValue(MyObject obj) {
    return (T) obj.value;
}

This will have an unchecked cast warning, but that's not worse than leaving the typing decision to your caller (so I'd just @SuppressWarnings("unchecked") it). If your caller uses the wrong target type, they will get a ClassCastException at runtime, which I assume goes well with your current contract. But you can keep c.cast(obj.getAsX()) if you want the exception to be raised in your own method.

With the above, your callers would just use:

String s = getValue(obj);
int i = getValue(obj);

If, however, you are actually converting data in getAs... methods, then you will need to cast in your generic getter after dispatching to the correct getAsX method, at least as ProGu suggested (i.e., return c.cast(obj.getAsX()) in each branch).

user_57615580
Related