多个通配符通用方法的正确语法？

Question

I'm having trouble getting the syntax correct for a generic method with multiple wildcards

First off I need two different wildcards because (while I've seen that '?' can be used to denote two different types) how will the compiler know when I use '?' ambiguously in the method.

So below I have my very illegal version where I use '*' as the second wildcard (is there some other wildcard character I can use???)

It may seem there is a programming error in the method but I can construct a type 'T' from a type '*' (I have constructors for that- basically taking a Google protocol buffer in and making a "full fledged object" out of it)

private <T, ? extends Database<*>, * extends GeneratedMessage> T getItem(String key, ? db, Hashtable<String, T> table, String message) throws GadsDataException {
    T returnValue = table.get(key);
    if (returnValue == null) {
        * temp = null;
        try {
            temp = db.get(key);
        }
        catch  (InvalidProtocolBufferException e) {
            throw new GadsDataException( message + key + " and hit: ", e);
        }
        if (temp != null) {
            returnValue = new T(temp);
            table.put(key, returnValue);
        }
    }
    return returnValue;
}

In desperation I tried a version without any wildcards (I don't like it as it does not preserve the type relations as the first did). But the compiler isn't too keen about it either. I guess I should look at the "Transformer" thing another poster mentioned.

private <T, D, G> T getItem(String key, D db, Hashtable<String, T> table, String message) throws GadsDataException {
        T returnValue = table.get(key);
        if (returnValue == null) {
            G temp = null;
            try {
                temp = db.get(key);
            }
            catch  (InvalidProtocolBufferException e) {
                throw new GadsDataException( message + key + " and hit: ", e);
            }
            if (temp != null) {
                returnValue = new T(temp);
                table.put(key, returnValue);
            }
        }
        return returnValue;
    }

So I'm still stuck on the constructor (as other posters have indicated I would be). I tried making the compiler happy by making an 'artifical' base class

/**
 * This is created as a base class for all objects that can
 * construct themselves from a Google Protocol Buffer with one
 * parameter.
 * 
 * This is just done for the sake of templatizing the methods
 * inside of the GadsLite API
 *
 */
public class ConstructorOneParameter {

    ConstructorOneParameter(GeneratedMessage G) {
        // don't actually do anything... the derived
        // class does all the work
        // We're doing this just to templatize the GadsLite methods
    }
}

Then what I did was use that to identify the type in the template method. Still the compiler wasn't happy.

private <T extends ConstructorOneParameter, D extends Database<G>, G extends GeneratedMessage> T 
        getItem(String key, D db, Hashtable<String, T> table, String message) throws GadsDataException {
    T returnValue = table.get(key);
    if (returnValue == null) {
        G temp = null;
        try {
            temp = db.get(key);
        }
        catch  (InvalidProtocolBufferException e) {
            throw new GadsDataException( message + key + " and hit: ", e);
        }
        if (temp != null) {
            returnValue = new T(temp);
            table.put(key, returnValue);
        }
    }
    return returnValue;
}

Several people have suggested a factory so I changed the line "returnValue = new T(temp);" into "returnValue = MessageObjectFactory create(temp);" Then for the factory I have:

public class MessageObjectFactory {

    public static <G extends GeneratedMessage, R extends Object> R create(G message) {
        R returnValue = null;
        if (message instanceof ArtccData.Artcc) {
            returnValue = new Artcc((ArtccData.Artcc)message);
        }
        return returnValue;
    }

}

I'm just doing one type right now as a proof of concept. Unfortunately even though everything is a subclass of Object the compiler isn't happy with the "returnValue = new Artcc(..." line complaining "cannot convert from Artcc to R". Is there a specific example of a "Transformer Factory"?

Answer 1

First off - there is absolutely zero point in declaring a wildcard ( ? ) in the generic parameter section. That section is for declaring type variables that you're going to refer to in the actual method signature & body. If you put a wildcard there, you obvious can't refer to them - and if you don't refer to them, they don't belong in the generic parameters (since your method won't vary depending on their values).

You ask

how will the compiler know when I use '?' ambiguously in the method.

which I consider quite confusing. Quite clearly it won't, which is exactly why you give the types names in the generic parameter block!

So given that, what is it you're trying to accomplish with the wildcards in the first example? Why wouldn't it work if you replaced the ? with U and the * with V (obviously the actual letters are arbitrary names), as in:

private <T, V extends GeneratedMessage, U extends Database<V>> T getItem(String key, U db, Hashtable<String, T> table, String message) throws GadsDataException {
    ...
    V temp = null;
    ...
}

(You may notice that I switched the order of the latter two parameters - forward references aren't allowed so the V has to appear before the U that depends on it).

This is similar to your second example except it maintains the constraints on the database and message parameter types. What didn't the compiler like about your version?

Answer 2

First you have to find a better way, than

new T(...)

as this is not allowed

Answer 3

Since all my type T's do have a constructor of the form T(G) I don't understand why I can't do new T(temp) . Also I edited my original question to display the failed hack described in the previous comment.

Java generics is an instrument to guarantee type safety, not to create different code depending on parameter. The compiler erases most type variables, so at runtime the actual type T is not known at all - thus we can't invoke any of its constructors (or create arrays of this type, by the way). This way we can use the generic method (or class) with types which were not yet existent when the method was created.

And actually, the compiler could not guarantee that all possible classes have such constructors, as there always could be later subclasses without.

So, in your case, you should think about using some kind of factory object, which takes a G and gives back the right T object, (for example a Transformer<G, T> type, like Andrzej proposed.)