StatusNeo

We all know that, common uses of generics includes creating typesafe parametrized collections, such as Set<T> and Map<K,V>, and single-element containers, such as ThreadLocal<T> and AtomicReference<T>. In all of these uses, it is the container that is parameterized.

If you think for a moment, this limits you to a fixed number of type parameters per container. Normally, that is exactly what you want. A Set has a single type parameter, representing its element type; a Map has two, representing its key and value types; and so forth.

Sometimes, however, you need a little more flexibility. For example, a database row can have arbitrarily many columns, and it would be nice to be able to access all of
them in a typesafe manner or something like the spring container. Luckily, there is an easy way to achieve this effect. The idea is to parameterize the key instead of the container. Then present the parameterized key to the container to insert or retrieve a value. The generic type system is used to guarantee that the type of the value agrees with its key.

Preview in new tab(opens in a new tab)

A simple example of this approach :

Consider a Favorites class that allows its clients to store and retrieve a favorite instance of arbitrarily many types !

Here’s a representation of this class :

The API for the Favorites class is simple, and looks like the code snippet below :

public class Favorites {
    public <T> void putFavorite(Class<T> type, T instance);
    public <T> T getFavorite(Class<T> type);
}

Implementation of the same :

public class Favorites {

    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance) {
    favorites.put(Objects.requireNonNull(type), type.cast(instance));
}

public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }
}

As you can see, the class consists of a Map whose key is of type Class with an unbounded wildcard. This means that every key can have a different parameterized type: one can be Class, the next Class, and so on. That’s where the heterogeneity comes from.

public class Class<T> {
      T cast(Object obj);
}