So here's a slightly tricky question (for me).

I have a generic object. Call it MyObject. This object has a method which returns something of the type T:

```
public class MyObject<T>
{
    private T _t;

    public MyObject(T t)
    {
        _t = t;
    }

    //...

    public T get()
    {
        return _t;
    }
}

```

(Obviously my "MyObject" does a bit more but that's the gist).

Now, I want to have a map of this type:

```
Map<String, MyObject<?>> m = new HashMap<>();

```

I want to be able to fetch maps using some predefined string name, and these maps can be of any MyObject. For example, I could call:

```
m.put("map_1", new MyObject<String>("String"));
m.put("map_2", new MyObject<Integer>(new Integer(3));
m.put("map_3", new MyObject<Long>(new Long(5));

```

etc.

But - and here's the tricky part - I want the map to "remember" the parameterized type of MyObject when I fetch some value from the map. Using

```
m.get("map_1");

```

would return a 

```
MyObject<Object> 

```

type, since the map was defined as containing 

```
MyObject<?> 

```

values. Thus:

```
m.get("map_1").get() // <-- This is an Object, not a String! 

```

What modification (if any) is possible, in order to be able to get the correct - full - information regarding the MyObject fetched object, such that invoking the last line (m.get("map\_1")) would return a 

```
MyObject<String>

```

Thanks :)

Amir.