Calling a static method on a generic type parameter in Java

Question

I would like to have something like this in Java :

import java.util.List;

class Query<T> {
    public List<T> fetch() {
        // Get the table name, T.tableName()
        // Fetch from /api/<table_name>
        // Parse and return data, T.parseJSON(jsonData)
    }
}

The intention here is to have a generic query builder, while each class T defines its specific tableName and parseJSON functions. For example,

class Article {
    public static String tableName() {
        return "article";
    }

    public static List<Article> parseJSON(String jsonData) {
        // Parse the json, build the articles
    }
}

How do I write the fetch function in the Query class?

They don't need to be. However, if they are instance methods, I don't have an Article object to use them. — svr
– svr, Commented Dec 29, 2015 at 17:48

T McKeown · Accepted Answer · 2015-12-29 17:40:41Z

1

Simply pass an instance of type T so you have access to the methods of that type. Notice the comments..

public List<T> fetch(T instance) {
    // Get the table name, instance.TableName();

    // Fetch from /api/<table_name>
    // Parse and return data, instance.parseJSON(jsonData)
}

answered Dec 29, 2015 at 17:40

T McKeown

12.9k1 gold badge27 silver badges35 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

yshavit Over a year ago

How are you going to create multiple T instances, for the List? And how are you going to invoke instance.parseJSON on an unbounded generic T? Both of these problems are solvable, but by the time you solve them you've essentially written a Function<String, T> in a more complicated way.

T McKeown Over a year ago

i am not saying this is a "good way" i'm just trying to give the OP an answer under the conditions he has created. A much better way is to provide a fetch that uses an instance that describes all the info needed.

yshavit · Accepted Answer · 2015-12-29 17:54:57Z

This is impossible; the specific instance of the T isn't known at compile time, which is when all static methods are resolved.

A common approach is to make Query<T> abstract, and provide a method:

protected abstract T parse(String data);

You can also use composition: have Query take a Function<String,T> in its constructor, and use it in fetch(). But one way or another, you have to have something that resolves at runtime, which is impossible with static methods.

If you use the composition approach, you can pass the json-reading function to each method, rather than the constructor:

public List<T> fetch(Function<String, T> parser) {
    ...
}

Note that if you do that, you may not even need to make Query generic; you can just make each method generic, as needed:

public class Query {
    public List<T> fetch(Function<String, T> parser) {
        ...
    }
}

Collectives™ on Stack Overflow

Calling a static method on a generic type parameter in Java

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related