返回语句应该在Java中使用泛型吗？

Question

I have a basic question about using the "Best Practices" in coding. (I'm using Java, but the question is general to OOP.) When writing method's for a class that are intended to be used in the long run, is it best to leave the return object with or without generics?

To be specific in my case, I'm returning a Map<String, Integer> with the method. Should I specify this in the return statement, or should I simply return a Map ?

Answer 1

It is best to use generics whenever possible. It will help avoid runtime exceptions, and it won't force the people using your code to do a bunch of ugly type casting. For example, if you use the following signature:

Map<String, Integer> getMap();

... then the consuming code might look like this:

Map<String, Integer> map = getMap();
Integer val = map.get(key);

... but if you use a signature like this:

Map getMap();

... the consuming code might look like this:

Map<String, Integer> map = (Map<String, Integer)getMap();
Integer val = map.get(key);

By using generics, not only do you save that (Map<String, Integer>) cast, but in the event that you change getMap to actually return a Map<String, Object> , you will get a compile-time error (which is easy to catch and fix), rather than possibly getting an exception when you call map.get(key) and the JRE tries to do an automatic cast of some random Object into an Integer.

Answer 2

You should definitely return a Map<String, Integer> instead of a plain Map if it makes sense in your method, as this will make it easier for others to use said method - after getting the Map<String, Integer> they will be able to retrieve String keys and Integer values without having to cast them from a generic Object every time (this also makes it a little more typesafe as this way they will know what the keys and values are without even reading the javadoc for your method).

So in short, definitely, return generics.

Answer 3

If the method is clearly intended to work with a certain type (ie only String ), then it's ok to return a List<String> . If the method is generic taking a type parameter T , you can return List<T> .

I would not simply return a Map , because usually it causes confusion and more boiler-plate code to convert to the desired type.

Answer 4

If you are returning a collection, you should include the generic type that is contained by the collection. For example:

public Map<String, Blammo> getBlammoMap(...)

is (IMHO) preferred to

public Map getBlammoMap(...)

Because it

1. Limits the options of a bad cast (ie kapowMap = (Map<String, Kapow> getBlammoMap() ).
2. Tells the consumer what the method is actually returning.

Answer 5

In general, your type parameters, both input and output, should capture the level of specificity of the precise function. In functional programming, they go so far as to say "the types are the documentation." If I were to see Map foo(Arg args) I would think that foo is in no way concerned with the types in the Map it returns, but somehow relies on Args for something." If I were to see Map<T,String> foo(T t, Arg arg) or Map<T, U> foo(T t, U u) I would think "OK, foo produces a Map based on the type of its t and with a String produced by Arg (or by the U from u )."

In terms of preference, clearly you want to be as clear as possible to the future programmer (yourself or others). Just as returning Map without type-params is obscure, so too would returning Map<String, Integer> might be overly restrictive (and thus misleading) if your foo would work equally well with, say, Map<String, Long>

Answer 6

I believe that more specific, the better. If your method is return a map that always has Strings as the key, and Integers as the value, then definitely use the Map has the return type. That way, any calling code knows exactly what they're getting. If the return type was just Map, then the calling code would have no idea what the class the keys and values are (Other than Object).

In general, you should probably always specify paramerize Maps, Lists, etc., so it's known exactly what it contains. This is very helpful when iterating over them and you can use a java foreach.

for (String currKey : myMap.keySet())
{
  System.out.println("curr Key: " + currKey + " curr Value: " + myMap.get(currKey));
}

This eliminates any extra iterators or casting.

Answer 7

Ho-ho-ho! A pretty New Year question.

You generally must (MUST) return a proper generic Map<Whatever, YouNeed> . It may sound crazy, but as soon as you use any generic type without type parameters, you're getting into trouble.

The trouble will be as follows: raw types, being used in the code, change the way methods (even seemingly non-related ones) are resolved. Find a presentation by Joshua Bloch and Bill Pugh called "Java Puzzlers: Scraping the Bottom of the Barrel" for details whle I'm preparing an example :) The video with details is at http://www.parleys.com/#id=2168&st=5 (you may want to scroll to slide 44, 5. "Glommer Pile")

So here's an example:

/**
 * (c) (as far as I know) Joshua Bloch and Bill Pugh, 2010
 */
public class Glommer<T> {
    String glom(Collection<?> objs) {
        String result = "";
        for (Object o : objs) result += o;
        return result;
    }

    int glom(List<Integer> ints) {
        int result = 0;
        for (int i : ints) result += i;
        return result;
    }

    public static void main(String args[]) {
        List<String> strings = Arrays.asList("1", "2", "3");
        System.out.println(new Glommer().glom(strings));
    }
}

Question is, whether it

• prints 6
• prints 123
• throws an exception,
• or does something else.

Try to guess. Then compile (yes it compiles) and see what happens.

Now that does not apply to your case. But having a habit of always specifying the type, even if it will be just Map<?,?> , is extremely helpful. You won't lose.

The obligatory Java Generics FAQ link