How to get instance of Class with its type parameters

Question

Hi,
Have any of you folks been dealing with generics long enough to show me how this should be written? Or point me to the answer (I have searched as well as I could).
I boiled down my situation to the included sample code, which is long only because of the inserted comments. And while boiling I accidentally came across a surprise solution (a bug?), but would obviously prefer a smoother solution.
My Questions (referred to in the code comments):
#1. Is there a way to get my parameterized type (classarg) without resorting to using the bogus (proto) object?
#2. Can anyone understand why the "C" and "D" attempts are different? (All I did was use an intermediate variable????) Is this a bug?
Thanks so much for any input.
/Mel
class GenericWeird
   /* a generic class -- just an example */
   static class CompoundObject<T1,T2>
      CompoundObject(T1 primaryObject, T2 secondaryObject)
   /* another generic class -- its main point is that its constr requires its type class */
   static class TypedThing<ValueType>
      TypedThing(Class<ValueType> valuetypeclass)
   // here I just try to create a couple of TypedThings
   public static void main(String[] args)
      // take it for granted that I need to instantiate these two objects:
      TypedThing<String>                        stringTypedThing = null;
      TypedThing<CompoundObject<String,String>> stringstringTypedThing = null;
      // To instantiate stringTypedThing is easy...
      stringTypedThing = new TypedThing<String>(String.class);
      // ...but to instantiate stringstringTypedThing is more difficult to call the constructor
      Class<CompoundObject<String,String>> classarg = null;
      // classarg has got to be declared to this type
      //    otherwise there will rightfully be compiler error about the constructor call below
      // This method body illustrates my questions
      classarg = exploringHowToGetTheArg();
      // the constructor call
      stringstringTypedThing = new TypedThing<CompoundObject<String,String>>(classarg);
   } // end main method
   // try compiling this method with only one of A,B,C,D sections uncommented at a time
   private static Class<CompoundObject<String,String>> exploringHowToGetTheArg()
      Class<CompoundObject<String,String>> classarg = null;
      /* Exhibit A: */
  ////     classarg = CompoundObject.class;
         results in compiler error "incompatible types"
         found   : java.lang.Class<GenericWeird.CompoundObject>
         required: java.lang.Class<GenericWeird.CompoundObject<java.lang.String,java.lang.String>>
               classarg = CompoundObject.class;
                                        ^
         I understand this.  But how to get the type information?
      /* It's obnoxious, but it looks like I will have to construct a temporary
          prototype instance of type
             CompoundObject<String,String>
          in order to get an instance of
             Class<CompoundObject<String,String>>
          (see my Question #1) */
      CompoundObject<String,String> proto = new CompoundObject<String,String>("foo", "fum");
      /* Exhibit B: */
  ////     classarg = proto.getClass();
         results in compiler error: "incompatible types"
         found   : java.lang.Class<capture of ? extends GenericWeird.CompoundObject>
         required: java.lang.Class<GenericWeird.CompoundObject<java.lang.String,java.lang.String>>
               classarg = proto.getClass();
                                        ^
      /* Exhibit C: */
  ////     classarg = proto.getClass().asSubclass(proto.getClass());
         results in compiler error: "incompatible types"
         found   : java.lang.Class<capture of ? extends capture of ? extends GenericWeird.CompoundObject>
         required: java.lang.Class<GenericWeird.CompoundObject<java.lang.String,java.lang.String>>
               classarg = proto.getClass().asSubclass(proto.getClass());
                                                     ^
      /* Exhibit D: (notice the similarity to C!): */
  ////     Class tmp1 = proto.getClass();
  ////     classarg = tmp1.asSubclass(tmp1);
      /* It compiles (see my Question #2) */
      return classarg;
   } // end method exploringHowToGetTheArg()
} // end class GenericWeird

Answer 1

Thanks so much, Bruce. (Oh my goodness, how would I have ever come up with that on my own?)
So in summary
This doesn't compile:
      classarg = (Class<CompoundObject<String,String>>)CompoundObject.class;but these do compile:
      classarg = (Class<CompoundObject<String,String>>)(Class)CompoundObject.class;or
      Class coclass = (Class)CompoundObject.class;
      classarg = (Class<CompoundObject<String,String>>)coclass;And this doesn't compile:
       classarg = proto.getClass().asSubclass(proto.getClass());but this does:
       Class tmp1 = proto.getClass();
       classarg = tmp1.asSubclass(tmp1);